import pdb from transformers import AutoTokenizer from torch import nn import os import time import torch.distributed as dist from tqdm import tqdm from torch.utils.data import DataLoader from torch.utils.data.distributed import DistributedSampler from dataset import * import wandb import gc import os import argparse import torch import torch.optim as optim import functools import torch.distributed as dist from torch.utils.data.distributed import DistributedSampler from torch.distributed.fsdp import ( FullyShardedDataParallel as FSDP, MixedPrecision, ShardingStrategy, FullStateDictConfig, StateDictType, ) from torch.distributed.fsdp.wrap import ( transformer_auto_wrap_policy, ) from modelforseminat_v5 import * from transformers import get_cosine_schedule_with_warmup ################################# 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 setup_model( model_name: str, # HF 路径 / 本地目录 dtype: str = "bf16", # "bf16" | "fp16" | "fp32" chunk_size_limit: int = 5, attn_impl: str = "flash_attention_2", load_model_dir: str | None = None, # 可能的 .pt 权重文件 decoder_layers: int = 1, encoder_layer: int = 1, mlp: bool = False, position_embedding_type: str = "absolute", base: str = None, length_loss_type: str = "ce" ): # --- 1. 构造 config ------------------------------------------------------- config = Olmo2ConfigForSemiNAT.from_pretrained( model_name, chunk_size_limit=chunk_size_limit, attn_implementation=attn_impl, decoder_layers=decoder_layers, encoder_layer=encoder_layer, mlp=mlp, position_embedding_type=position_embedding_type, length_loss_type=length_loss_type ) # pdb.set_trace() # --- 2. 按需设定 dtype ---------------------------------------------------- dtype_map = {"bf16": torch.bfloat16, "fp16": torch.float16, "fp32": torch.float32} torch_dtype = dtype_map.get(dtype, torch.float32) # --- 3. 加载基础模型 ------------------------------------------------------ if base == "scratch": model = Olmo2ForCausalLMForSemiNAT(config).to(torch_dtype) # pdb.set_trace() elif base == "pretrained": model = Olmo2ForCausalLMForSemiNAT.from_pretrained( model_name, config=config, torch_dtype=torch_dtype ) # pdb.set_trace() # --- 4. 若给定 .pt，则加载其参数 ---------------------------------------- if load_model_dir and os.path.isfile(load_model_dir) and load_model_dir.endswith(".pt"): ckpt = torch.load(load_model_dir, map_location="cpu", weights_only=True) missing_keys, unexpected_keys = model.load_state_dict(ckpt, strict=False) print(f"[INFO] Loaded weights from {load_model_dir}") 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) # pdb.set_trace() else: print("[INFO] No extra .pt weights loaded") # --- 5. tokenizer -------------------------------------------------------- tokenizer = AutoTokenizer.from_pretrained(model_name) # pdb.set_trace() # config = AutoConfig.from_pretrained(model_name) # model = Olmo2ForCausalLMForSemiNAT(config) # 注意这里不用 from_pretrained # tokenizer = AutoTokenizer.from_pretrained(model_name) return model, tokenizer def reduce_mean(tensor: torch.Tensor) -> torch.Tensor: # 聚合所有 rank 的 tensor 并求平均 dist.all_reduce(tensor, op=dist.ReduceOp.SUM) tensor /= dist.get_world_size() return tensor 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=args.project_name, name=args.run_name) local_rank = int(os.environ['LOCAL_RANK']) DEVICE = f"cuda:{local_rank}" # pdb.set_trace() model, tokenizer = setup_model(args.model_path,args.dtype,args.chunk_size_limit,args.attn_implementation,args.ptm_model_path,args.decoder_layers,args.encoder_layers,args.mlp,args.position_embedding_type,args.base,args.length_loss_type) optimizer = optim.AdamW( model.parameters(), lr=args.lr, betas=args.betas, weight_decay=args.weight_decay, eps=args.eps, ) 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, drop_last=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) 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 ) if args.resume_path: checkpoint = torch.load(args.resume_path, map_location=DEVICE, weights_only=True) missing_keys, unexpected_keys = model.load_state_dict(checkpoint["model"], 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) full_optim_state = checkpoint["optimizer"] sharded_state = FSDP.shard_full_optim_state_dict(full_optim_state, model) FSDP.optim_state_dict_to_device( sharded_state, device=torch.cuda.current_device(), # 当前 GPU dtype=torch.bfloat16 # 或 p.dtype，如果你混用 fp16/bf16 ) optimizer.load_state_dict(sharded_state) scheduler.load_state_dict(checkpoint["scheduler"]) global_step = checkpoint.get("global_step", 0) print(f"Size of train dataset: {len(train_dataset)}") setup() 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) mp_policy = MixedPrecision( param_dtype=torch.bfloat16, reduce_dtype=torch.bfloat16, buffer_dtype=torch.bfloat16, ) 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) 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): model.train() local_rank = int(os.environ['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 = args.alpha * loss1 + loss2 # loss1_list.append(loss1.item()) # loss2_list.append(loss2.item()) # loss_list.append(loss.item()) loss1_scalar = reduce_mean(loss1.detach()).item() loss2_scalar = reduce_mean(loss2.detach()).item() total_loss_scalar = reduce_mean(loss.detach()).item() # pdb.set_trace() loss.backward() optimizer.step() scheduler.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() full_optim_state = FSDP.full_optim_state_dict(model, optimizer, rank0_only=True) 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({ "model": cpu_state, "optimizer": optimizer.state_dict(), "scheduler": scheduler.state_dict() if scheduler else None, "global_step": global_step, "args": vars(args), }, save_path) if rank == 0: loss1_list.append(loss1_scalar) loss2_list.append(loss2_scalar) loss_list.append(total_loss_scalar) inner_pbar.update(1) if args.use_wandb and rank == 0: wandb.log({ "Length prediction loss (L1)": sum(loss1_list[-20:]) / len(loss1_list[-20:]), "NAT loss (L2)": sum(loss2_list[-20:]) / len(loss2_list[-20:]), f"Loss {args.alpha} * L1 + L2": 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() 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('--project_name', 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) parser.add_argument('--resume_path', type=str,default=None) parser.add_argument('--attn_implementation', type=str) parser.add_argument('--ptm_model_path', type=str,default=None) parser.add_argument('--decoder_layers', type=int,default=1) parser.add_argument('--encoder_layers', type=int,default=1) parser.add_argument('--mlp', action='store_true', default=False) parser.add_argument('--position_embedding_type', type=str, default="absolute",choices=["absolute","relative"]) parser.add_argument('--base', type=str, default="scratch",choices=["scratch","pretrained"]) parser.add_argument('--length_loss_type', type=str, default="ce",choices=["mse","ce"]) parser.add_argument('--alpha', type=float, default=0.4) args = parser.parse_args() # pdb.set_trace() torch.manual_seed(args.seed) fsdp_main(args)