import json import pdb from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer from transformers.models.auto.modeling_auto import MODEL_FOR_IMAGE_TEXT_TO_TEXT_MAPPING_NAMES import copy from transformers.modeling_outputs import ( MoeCausalLMOutputWithPast, MoeModelOutputWithPast, ) from collections import defaultdict import numpy as np import math from torch import nn # import pandas as pd from transformers.cache_utils import Cache, DynamicCache, StaticCache from dataclasses import dataclass # from transformers.models.olmoe.configuration_olmoe import OlmoeConfig # from transformers.models.olmoe.modeling_olmoe import OlmoeMLP, OlmoeAttention, OlmoeFlashAttention2, OlmoeSdpaAttention, OlmoeRMSNorm, OlmoeSparseMoeBlock, apply_rotary_pos_emb, repeat_kv, OlmoeRotaryEmbedding import os import sys import torch.distributed as dist from tqdm import tqdm from torch.utils.data import DataLoader from torch.utils.data.distributed import DistributedSampler import transformers import pickle # from transformers.models.olmoe.configuration_olmoe import OlmoeConfig from dataset import * # from utils import flash_attn_forward, flash_attn_prepare_decoder_attention_mask, get_multiround_data # from peft import (get_peft_model, PeftModel) import random # from config import * from datasets import Dataset, DatasetDict, load_dataset import wandb import gc import os import argparse import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim import functools from torch.optim.lr_scheduler import StepLR import torch.nn.functional as F import torch.distributed as dist import torch.multiprocessing as mp from torch.nn.parallel import DistributedDataParallel as DDP from torch.utils.data.distributed import DistributedSampler from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import ( checkpoint_wrapper, CheckpointImpl) from torch.distributed.fsdp import ( FullyShardedDataParallel as FSDP, MixedPrecision, BackwardPrefetch, ShardingStrategy, FullStateDictConfig, StateDictType, ) from torch.distributed.fsdp.wrap import ( transformer_auto_wrap_policy, enable_wrap, wrap, ) from functools import partial from torch.utils.data import DataLoader from pathlib import Path from typing import Type, List, Optional, Tuple, Union from modelforseminat_v5 import * from transformers import get_cosine_schedule_with_warmup # from torch.optim.lr_scheduler import _LRScheduler # class WarmupCosineScheduler(_LRScheduler): # def __init__(self, # optimizer, # warmup_steps, # total_steps, # min_lr=0.0, # last_epoch=-1): # # self.warmup_steps = warmup_steps # self.total_steps = total_steps # self.min_lr = min_lr # if isinstance(warmup_steps, float) and 0 < warmup_steps < 1: # self.warmup_steps = int(warmup_steps * total_steps) # else: # self.warmup_steps = int(warmup_steps) # super().__init__(optimizer, last_epoch) # def get_lr(self): # step = self.last_epoch + 1 # lrs = [] # for base_lr in self.base_lrs: # if step < self.warmup_steps: # # Linear warmup # lr = base_lr * step / self.warmup_steps # else: # # Cosine decay # progress = (step - self.warmup_steps) / max( # 1, self.total_steps - self.warmup_steps) # cosine_decay = 0.5 * (1 + math.cos(math.pi * progress)) # lr = self.min_lr + (base_lr - self.min_lr) * cosine_decay # lrs.append(lr) # return lrs ################################# FSDP Config ##################################### def setup(): # initialize the process group local_rank = int(os.environ['LOCAL_RANK']) torch.cuda.set_device(local_rank) dist.init_process_group( backend='nccl', init_method='env://', ) def cleanup(): gc.collect() torch.cuda.empty_cache() dist.destroy_process_group() def get_fsdp_device(): # 每个进程初始化分布式环境后调用 local_rank = int(os.environ.get("LOCAL_RANK", 0)) # torchrun 自动设置 device = torch.device(f"cuda:{local_rank}") torch.cuda.set_device(device) return device # def load_trained_model(model_name): # DEVICE = "cuda" if torch.cuda.is_available() else "cpu" # olmo_path = "/AIRvePFS/ai4science/users/ai4science/users/zyk/seminat_backup/model/OLMo-2-0425-1B" # pt_path = "/AIRvePFS/ai4science/users/ai4science/users/zyk/seminat/ckp/sft-v4-0616-1w-1e3-chunklimit5-jueduipos/sft-v4-1e3-len4-fc-chunklimit4-jueduipos-epoch_136.pt" # config_path = "/AIRvePFS/ai4science/users/ai4science/users/zyk/seminat_backup/model/OLMo-2-0425-1B/config.json" # config = AutoConfig.from_pretrained(olmo_path) # model = Olmo2ForCausalLMForSemiNAT.from_pretrained(olmo_path, # config=config, # torch_dtype=torch.bfloat16) # state_dict = torch.load(pt_path, map_location=DEVICE, weights_only=True) # missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False) # print( # f"Loaded with {len(missing_keys)} missing keys and {len(unexpected_keys)} unexpected keys." # ) # if missing_keys: # print("Missing keys:", missing_keys) # if unexpected_keys: # print("Unexpected keys:", unexpected_keys) # model = model.to(DEVICE) # tokenizer = AutoTokenizer.from_pretrained(olmo_path) # return model, tokenizer # def setup_model(model_name,device): # model = Olmo2ForCausalLMForSemiNAT.from_pretrained(model_name,torch_dtype=torch.bfloat16,device_map=device) # tokenizer = AutoTokenizer.from_pretrained(model_name) # # config = AutoConfig.from_pretrained(model_name) # # model = Olmo2ForCausalLMForSemiNAT(config) # 注意这里不用 from_pretrained # # tokenizer = AutoTokenizer.from_pretrained(model_name) # return model, tokenizer def setup_model(model_name, type): # pdb.set_trace() if type == "bf16": model = Olmo2ForCausalLMForSemiNAT.from_pretrained( model_name, torch_dtype=torch.bfloat16 ) elif type == "fp16": model = Olmo2ForCausalLMForSemiNAT.from_pretrained( model_name, torch_dtype=torch.float16 ) else: model = Olmo2ForCausalLMForSemiNAT.from_pretrained( model_name ) tokenizer = AutoTokenizer.from_pretrained(model_name) # config = AutoConfig.from_pretrained(model_name) # model = Olmo2ForCausalLMForSemiNAT(config) # 注意这里不用 from_pretrained # tokenizer = AutoTokenizer.from_pretrained(model_name) return model, tokenizer def collate_fn(batch): # 过滤 None batch = [x for x in batch if x is not None] if len(batch) == 0: return None # 如果整 batch 都无效 input_ids, labels, attention_mask, slice_arr, slice_label = zip(*batch) return ( torch.stack(input_ids), torch.stack(labels), torch.stack(attention_mask), torch.stack(slice_arr), torch.stack(slice_label) ) def fsdp_main(args): local_rank = int(os.environ['LOCAL_RANK']) rank = int(os.environ['RANK']) world_size = int(os.environ['WORLD_SIZE']) if args.use_wandb and rank == 0: wandb.init(entity="SemiNAT", project="SemiNAT-SFT", name=args.run_name) local_rank = int(os.environ['LOCAL_RANK']) device = f"cuda:{local_rank}" # model, tokenizer = setup_model(args.model_path, args.dtype, device) model, tokenizer = setup_model(args.model_path,device) # model, tokenizer = load_trained_model(args.model_path) model.config.chunk_size_limit = args.chunk_size_limit # if ".pkl" in args.data_path: # train_dataset = pickle.load(open(args.data_path, "rb")) # else: # datasets = pd.read_parquet(args.data_path) # train_dataset = eval(f"{args.data_type}")( # tokenizer, # datasets, # args.max_length, # args.data_processess_num) # train_sampler = DistributedSampler(train_dataset, # rank=rank, # num_replicas=world_size, # shuffle=True) # train_dataloader = DataLoader(dataset=train_dataset, # sampler=train_sampler, # batch_size=args.batch_size) train_dataset = eval(f"{args.data_type}")( tokenizer, args.data_path, args.max_length ) train_sampler = DistributedSampler(train_dataset, rank=rank, num_replicas=world_size, shuffle=True) train_dataloader = DataLoader(dataset=train_dataset, sampler=train_sampler, batch_size=args.batch_size, num_workers=args.data_processess_num, collate_fn=collate_fn) # pdb.set_trace() print(f"Size of train dataset: {len(train_dataset)}") setup() # Olmo2DecoderLayerForSemiNAT_auto_wrap_policy = functools.partial( # transformer_auto_wrap_policy, # transformer_layer_cls={ # Olmo2DecoderLayerForSemiNAT, # NATEncoderForSemiNAT, # NATDecoderForSemiNAT, # }) Olmo2DecoderLayerForSemiNAT_auto_wrap_policy = functools.partial( transformer_auto_wrap_policy, transformer_layer_cls={ Olmo2DecoderLayer, Olmo2DecoderLayerForSemiNAT } ) sharding_strategy: ShardingStrategy = ShardingStrategy.FULL_SHARD #for Zero2 and FULL_SHARD for Zero3 torch.cuda.set_device(local_rank) # local_rank = int(os.environ['LOCAL_RANK']) # device = torch.device(f"cuda:{local_rank}") # model = model.to(device) # if bf16_ready: mp_policy = MixedPrecision( param_dtype=torch.bfloat16, reduce_dtype=torch.bfloat16, buffer_dtype=torch.bfloat16, ) # else: # mp_policy = None # defaults to fp32 # if args.use_lora: # model = get_peft_model(model, lora_config) # pdb.set_trace() # model is on CPU before input to FSDP model = FSDP(model, auto_wrap_policy=Olmo2DecoderLayerForSemiNAT_auto_wrap_policy, mixed_precision=mp_policy, sharding_strategy=sharding_strategy, device_id=torch.cuda.current_device(), use_orig_params=True) optimizer = optim.AdamW( model.parameters(), lr=args.lr, betas=args.betas, weight_decay=args.weight_decay, eps=args.eps, ) # pdb.set_trace() # scheduler = StepLR(optimizer, step_size=1, gamma=args.gamma) # scheduler = WarmupCosineScheduler( # optimizer=optimizer, # 优化器对象 # warmup_steps=args.warmup_steps, # warmup 步数（或比例） # total_steps=args.total_steps, # 总训练步数 # min_lr=args.min_lr # 最小学习率 # ) num_training_steps = args.epochs * len(train_dataloader) # 总训练步数 num_warmup_steps = num_training_steps * args.warmup_ratio scheduler = get_cosine_schedule_with_warmup( optimizer, num_warmup_steps=num_warmup_steps, num_training_steps=num_training_steps ) torch.autograd.set_detect_anomaly(True) loss1_list = [] loss2_list = [] loss_list = [] global_step = 0 start_time = time.time() for epoch in range(1, args.epochs + 1): # t0 = time.time() model.train() local_rank = int(os.environ['LOCAL_RANK']) # fsdp_loss = torch.zeros(2).to(local_rank) if train_sampler: train_sampler.set_epoch(epoch) if rank == 0: inner_pbar = tqdm(range(len(train_dataloader)), colour="blue", desc="r0 Training Epoch") memories = [] for batch in train_dataloader: if batch is None: continue optimizer.zero_grad() loss1, loss2 = model(input_ids=batch[0], labels=batch[1], attention_mask=batch[2], slice_pos=batch[3], slice_label=batch[4], use_cache=False).loss loss = loss1 + loss2 # loss = loss2 loss1_list.append(loss1.item()) loss2_list.append(loss2.item()) loss_list.append(loss.item()) # pdb.set_trace() # if torch.isnan(loss): # print(f"Step {global_step}: loss is NaN, entering pdb …") # pdb.set_trace() # print(f"loss1:{loss1},loss2:{loss2}") loss.backward() # 按参数计算 # for name, module in model.named_modules(): # total_norm = 0.0 # param_count = 0 # for param in module.parameters(recurse=False): # if param.grad is not None: # total_norm += param.grad.data.norm(2).item()**2 # param_count += 1 # if param_count > 0: # if args.use_wandb and rank == 0: # total_norm = total_norm**0.5 # wandb.log({f"grad_norm/{name}": total_norm}, # step=global_step) optimizer.step() mem = torch.cuda.memory_allocated() / (1024 ** 2) memories.append(mem) global_step += 1 if global_step % args.save_steps == 0: save_policy = FullStateDictConfig(offload_to_cpu=True, rank0_only=True) with FSDP.state_dict_type(model, StateDictType.FULL_STATE_DICT, save_policy): cpu_state = model.state_dict() if rank == 0: print(f"--> steps: {str(global_step)} saving model ...") if not os.path.exists(args.save_path): os.makedirs(args.save_path) save_name = f"{args.save_name}-steps_{str(global_step)}.pt" print(f"--> saving as model name {save_name}") save_path = os.path.join(args.save_path, save_name) torch.save(cpu_state, save_path) if rank == 0: inner_pbar.update(1) if args.use_wandb and rank == 0: wandb.log({ "length prediction loss": sum(loss1_list[-20:]) / len(loss1_list[-20:]), "nat loss": sum(loss2_list[-20:]) / len(loss2_list[-20:]), "loss": sum(loss_list[-20:]) / len(loss_list[-20:]), "lr": scheduler.get_last_lr()[0] }) avg_mem = sum(memories) / len(memories) print(f"Average memory usage over {len(memories)} steps: {avg_mem:.2f} MB") dist.all_reduce(loss, op=dist.ReduceOp.SUM) if rank == 0: inner_pbar.close() scheduler.step() # if rank == 0: # print(f"--> entering save model state") # save_policy = FullStateDictConfig(offload_to_cpu=True, rank0_only=True) # with FSDP.state_dict_type(model, StateDictType.FULL_STATE_DICT, # save_policy): # cpu_state = model.state_dict() # if rank == 0: # print(f"--> epoch: {str(epoch)} saving model ...") # if not os.path.exists(args.save_path): # os.makedirs(args.save_path) # save_name = f"{args.save_name}-epoch_{str(epoch)}.pt" # print(f"--> saving as model name {save_name}") # save_path = os.path.join(args.save_path, save_name) # torch.save(cpu_state, save_path) end_time = time.time() print(f"Training time: {end_time - start_time} seconds") dist.barrier() cleanup() ################################# FSDP Config ##################################### if __name__ == "__main__": # Training settings parser = argparse.ArgumentParser() parser.add_argument('--batch-size', type=int, default=4, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--model_path', type=str) parser.add_argument('--save_path', type=str) parser.add_argument('--save_name', type=str) parser.add_argument('--data_path', type=str) parser.add_argument('--data_type', type=str) parser.add_argument('--run_name', type=str) parser.add_argument('--max_length', type=int) parser.add_argument('--chunk_size_limit', type=int) parser.add_argument('--save_steps', type=int, default=5000) parser.add_argument('--data_processess_num', type=int, default=8) parser.add_argument('--epochs', type=int, default=2, metavar='N', help='number of epochs to train (default: 3)') parser.add_argument('--lr', type=float, default=.002, metavar='LR', help='learning rate (default: .002)') parser.add_argument('--weight_decay', type=float) parser.add_argument('--betas', type=float, nargs=2) parser.add_argument('--eps', type=float) parser.add_argument('--warmup_ratio', type=float) parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument('--use_lora', action='store_true', default=False) parser.add_argument("--use_wandb", action="store_true", help="whether to use wandb") parser.add_argument('--dtype', type=str) args = parser.parse_args() torch.manual_seed(args.seed) fsdp_main(args)