import os import logging import torch import torch.distributed as dist import torch.nn as nn import torch.optim as optim import datetime import torch.nn.functional as F from contextlib import nullcontext from torch.nn.parallel import DistributedDataParallel as DDP from torch.utils.data import DataLoader, DistributedSampler from ml_collections.config_dict import ConfigDict from rna_dataset import RNADataset, RNACollater, RNACollater_v2 from dmt import DMT from torch_scatter import scatter from torch.optim.lr_scheduler import CosineAnnealingLR from collections import deque from torch.cuda.amp import GradScaler # CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node=2 main_parallel.py # CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node=4 main_parallel.py # CUDA_VISIBLE_DEVICES=4,5,6,7,8,9 torchrun --nnodes=1 --nproc_per_node=6 main_parallel.py --rdzv_backend=c10d --rdzv_endpoint=localhost:0 def info_nce_loss(z1, z2, temperature=0.05): z1 = F.normalize(z1, dim=1) z2 = F.normalize(z2, dim=1) B = z1.size(0) z = torch.cat([z1, z2], dim=0) # (2B, D) sim = torch.matmul(z, z.T) / temperature # (2B, 2B) mask = torch.eye(2 * B, device=z.device, dtype=torch.bool) sim.masked_fill_(mask, -9e15) pos_idx = torch.cat([torch.arange(B, 2 * B), torch.arange(0, B)]).to(z.device) pos_sim = sim[torch.arange(2 * B), pos_idx] # Uncomment the following lines if you want to mask out the positive pairs # pos_mask = torch.zeros_like(sim, dtype=torch.bool) # pos_mask[torch.arange(2 * B), pos_idx] = True # sim.masked_fill_(pos_mask, -9e15) loss = -pos_sim + torch.logsumexp(sim, dim=1) return loss.mean() class GatherLayer(torch.autograd.Function): """ Gather tensors from all workers with support for backward propagation: This implementation does not cut the gradients as torch.distributed.all_gather does. """ @staticmethod def forward(ctx, x): output = [ torch.zeros_like(x) for _ in range(torch.distributed.get_world_size()) ] torch.distributed.all_gather(output, x) return tuple(output) @staticmethod def backward(ctx, *grads): all_gradients = torch.stack(grads) torch.distributed.all_reduce(all_gradients) return all_gradients[torch.distributed.get_rank()] def all_gather_with_grad(tensors): """ Performs all_gather operation on the provided tensors. Graph remains connected for backward grad computation. """ # Queue the gathered tensors world_size = torch.distributed.get_world_size() # There is no need for reduction in the single-proc case if world_size == 1: return tensors tensor_all = GatherLayer.apply(tensors) return torch.cat(tensor_all, dim=0) def train(configs): local_rank, world_size, rank = int(os.environ["LOCAL_RANK"]), int(os.environ["WORLD_SIZE"]), int(os.environ["RANK"]) # os.environ['MASTER_ADDR'] = 'localhost' # os.environ['MASTER_PORT'] = '29500' dist.init_process_group("gloo", rank=rank, world_size=world_size) torch.cuda.set_device(local_rank) date_str = datetime.datetime.now().strftime("%Y%m%d_%H%M") if rank == 0: total_batch_size = world_size * configs.batch_size log_dir = f"/home/hui007/rna/first_stage/log/train_{date_str}_totalbatchsize{total_batch_size}" os.makedirs(log_dir, exist_ok=True) log_path = os.path.join(log_dir, f"train_{date_str}.log") logger = logging.getLogger() logger.setLevel(logging.INFO) # 移除已有 handler for handler in logger.handlers[:]: logger.removeHandler(handler) file_handler = logging.FileHandler(log_path, mode='a') formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') file_handler.setFormatter(formatter) logger.addHandler(file_handler) logger.info(f"Using DDP with total {world_size} GPUS...") # z1_queue = deque(maxlen=configs.memory_size) # z2_queue = deque(maxlen=configs.memory_size) model = DMT(configs) resume_path = configs.get('resume_path', None) if resume_path is not None and os.path.exists(resume_path): model.load_state_dict(torch.load(resume_path, map_location=f"cuda:{local_rank}")) if rank == 0: logging.info(f"Loaded checkpoint from {resume_path}") device = torch.device(f'cuda:{local_rank}') model = model.to(device) ddp_model = DDP(model, device_ids=[local_rank], find_unused_parameters=True) # if rank == 0: # torch.save(ddp_model.module.state_dict(), f"/home/hui007/rna/first_stage/model_checkpoint/test.pth") dataset = RNADataset('/home/hui007/rna/rna_repr/zhiyuan/train_data_final.npz', protenix_emb_path='/home/hui007/rna/first_stage/scaled_tiny_protenix_emb_1d') sampler = DistributedSampler(dataset, num_replicas=world_size, rank=rank) dataloader = DataLoader(dataset, batch_size=configs.batch_size, sampler=sampler, drop_last=True, collate_fn=RNACollater_v2()) # optimizer = optim.SGD(ddp_model.parameters(), lr=0.01) optimizer = torch.optim.AdamW(ddp_model.parameters(), lr=1e-5, weight_decay=0.01) scheduler = CosineAnnealingLR(optimizer, T_max=configs.epoch, eta_min=1e-6) global_step = 0 loss_accum = 0.0 contrast_loss_accum = 0.0 denoising_loss_accum = 0.0 count_accum = 0 scaler = GradScaler(enabled=(configs.dtype in ["fp16", "bf16"])) for epoch in range(configs.epoch): sampler.set_epoch(epoch) ddp_model.train() for g1, g2 in dataloader: g1 = g1.to(device) g2 = g2.to(device) eval_precision = { "fp32": torch.float32, "bf16": torch.bfloat16, "fp16": torch.float16, }[configs.dtype] enable_amp = ( torch.autocast(device_type="cuda", dtype=eval_precision) if torch.cuda.is_available() else nullcontext() ) optimizer.zero_grad() with enable_amp: z1, denoising_loss1 = ddp_model(g1) z2, denoising_loss2 = ddp_model(g2) z1_all = all_gather_with_grad(z1) z2_all = all_gather_with_grad(z2) # if len(msa_queue) > 0: # msa_output_extended = msa_output + list(msa_queue) # dmt_output_extended = dmt_output + list(dmt_queue) # else: # msa_output_extended = msa_output # dmt_output_extended = dmt_output # 更新队列（detach 防止梯度传播 # for x in msa_output: # msa_queue.append(x.detach()) # for x in dmt_output: # dmt_queue.append(x.detach()) contrast_loss = info_nce_loss(z1_all, z2_all, temperature=0.05) denoising_loss = (denoising_loss1 + denoising_loss2) / 2 loss = 0.5 * contrast_loss + denoising_loss # print(loss, loss.requires_grad, loss.grad_fn) # loss.backward() scaler.scale(loss).backward() # torch.nn.utils.clip_grad_norm_(ddp_model.parameters(), max_norm=1.0) # 梯度裁剪 # optimizer.step() scaler.step(optimizer) scaler.update() global_step += 1 if rank == 0: print(f"Epoch [{epoch}/{configs.epoch}], Step [{global_step}], Loss: {loss.item():.4f}") contrast_loss_accum += contrast_loss.item() denoising_loss_accum += denoising_loss.item() loss_accum += loss.item() count_accum += 1 if global_step % 5 == 0: avg_loss = loss_accum / count_accum avg_denoising_loss = denoising_loss_accum / count_accum avg_contrast_loss = contrast_loss_accum / count_accum print(f"Epoch: {epoch}, Step: {global_step}, Avg Loss: {avg_loss:.4f}") logging.info(f"Epoch: [{epoch}/{configs.epoch}], Step: {global_step}, avg_contrast_loss: {avg_contrast_loss:.4f}, avg_denoising_loss: {avg_denoising_loss:.4f}, Avg Loss: {avg_loss:.4f}") loss_accum = 0.0 contrast_loss_accum = 0.0 denoising_loss_accum = 0.0 count_accum = 0 if rank == 0 and epoch % 100 == 0: os.makedirs(f'/home/hui007/rna/first_stage/model_checkpoint/{date_str}', exist_ok=True) torch.save(ddp_model.module.state_dict(), f"/home/hui007/rna/first_stage/model_checkpoint/{date_str}/epoch{epoch}_{date_str}.pth") scheduler.step() torch.cuda.empty_cache() dist.destroy_process_group() def main(): configs = { # 'resume_path': '/home/hui007/rna/model_checkpoint/torchrun_model_epoch_15_20250610_1732.pth', 'resume_path': None, 'epoch': 10000, 'batch_size': 64, # per GPU # 'memory_size': 16, "dtype": "bf16", # default training dtype: bf16 'new_aa': True, 'sqrt_dis': False, 'hidden_dim': 384, 'e2n_ratio': 6, 'n_blocks': 12, 'in_res_node_features': 4, 'pos_mask_type': 'none', 'enable_llm': False, 'use_struc_emb': False, 'pos_dim': 72, 'mlp_ratio': 4, 'disable_dist': False, 'dist_mask_type': 'none', 'n_heads': 8, 'in_res_edge_features': 5, 'not_pair_update': False, 'dropout': 0.0, 'trans_ver': 'v3', "use_protenix_emb": True } configs = ConfigDict(configs) train(configs) if __name__ == "__main__": main()