#!/usr/bin/env python3 import os import time import argparse import json import yaml import math import copy import torch import torch.nn as nn import torch.nn.functional as F from safetensors.torch import save_file as safetensors_save from model import ConditionalMDLM, apply_mask from dataset import create_dataloaders def get_lr(step, warmup_steps, max_steps, max_lr, min_lr_ratio=0.0): if step < warmup_steps: return max_lr * step / warmup_steps progress = (step - warmup_steps) / max(1, max_steps - warmup_steps) min_lr = max_lr * min_lr_ratio return min_lr + (max_lr - min_lr) * 0.5 * (1 + math.cos(math.pi * progress)) def _meta(step, best_val_loss, config): mc = config.get("model", {}) return { "step": str(step), "best_val_loss": f"{best_val_loss:.6f}", "encoder_model": str(mc.get("encoder_model", "unknown")), "decoder_tokenizer": str(mc.get("decoder_tokenizer", "unknown")), "vocab_size": str(mc.get("vocab_size", 0)), "hidden_dim": str(mc.get("hidden_dim", 0)), "config_json": json.dumps(config, default=str), } def save_checkpoint(path, step, best_val_loss, model, ema_model, optimizer, config): torch.save({ "step": step, "best_val_loss": best_val_loss, "model": model.state_dict(), "ema_model": ema_model.state_dict(), "optimizer": optimizer.state_dict(), "config": config, }, path) def save_ema(path, step, best_val_loss, ema_model, config): st_path = path.replace(".pt", ".safetensors") safetensors_save(ema_model.state_dict(), st_path, metadata=_meta(step, best_val_loss, config)) def train(config, resume=False): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print(f"Device: {device}\nGPU: {torch.cuda.get_device_name() if device.type == 'cuda' else 'N/A'}") mc, tc = config["model"], config["training"] model = ConditionalMDLM(config).to(device) total_params, trainable_params = model.count_params() print(f"Model params: {total_params:,} total, {trainable_params:,} trainable") ema_decay = tc.get("ema_decay", 0.9999) ema_model = copy.deepcopy(model) ema_model.eval() for p in ema_model.parameters(): p.requires_grad_(False) batch_size = tc.get("batch_size", 128) print(f"Loading data... (Batch size: {batch_size})") train_loader, val_loader = create_dataloaders(config) optimizer = torch.optim.AdamW(model.parameters(), lr=tc["lr"], weight_decay=tc["weight_decay"]) # KHÔNG DÙNG GradScaler cho bfloat16 grad_accum = tc.get("grad_accum", 1) ckpt_dir = config.get("_ckpt_dir", "checkpoints") os.makedirs(ckpt_dir, exist_ok=True) start_step, best_val_loss = 0, float("inf") if resume: ckpt_path = f"{ckpt_dir}/latest.pt" if not os.path.exists(ckpt_path): ckpt_path = f"{ckpt_dir}/best.pt" if os.path.exists(ckpt_path): ckpt = torch.load(ckpt_path, map_location=device, weights_only=False) model.load_state_dict({k.replace("_orig_mod.", ""): v for k, v in ckpt["model"].items()}) optimizer.load_state_dict(ckpt["optimizer"]) start_step, best_val_loss = ckpt["step"], ckpt.get("best_val_loss", float("inf")) if "ema_model" in ckpt: ema_model.load_state_dict({k.replace("_orig_mod.", ""): v for k, v in ckpt["ema_model"].items()}) model.train() step = start_step max_steps, log_every, eval_every = tc["max_steps"], tc["log_every"], tc.get("eval_every", 500) early_stop_patience = tc.get("early_stop_patience", 5000) running_loss, running_acc, running_count, total_samples = 0.0, 0.0, 0, 0 micro_step = 0 t0_global = time.time() data_iter = iter(train_loader) print(f"\n=== Training started (step {step}/{max_steps}) ===") while step < max_steps: try: batch = next(data_iter) except StopIteration: data_iter = iter(train_loader) batch = next(data_iter) token_ids = batch["token_ids"].to(device) embedding = batch["embedding"].to(device) padding_mask = batch["padding_mask"].to(device) masked_ids, target_mask, mask_ratio = apply_mask(token_ids, mc["mask_token_id"], padding_mask) if micro_step == 0: lr = get_lr(step, tc["warmup_steps"], max_steps, tc["lr"], tc.get("min_lr_ratio", 0.0)) for pg in optimizer.param_groups: pg["lr"] = lr optimizer.zero_grad() # Dùng bfloat16 siêu việt của H100 with torch.amp.autocast('cuda', dtype=torch.bfloat16): hidden = model.forward_hidden(masked_ids, embedding, padding_mask) mask_flat = target_mask.view(-1) pad_flat = padding_mask.view(-1) active_mask = mask_flat & (~pad_flat) total_active = active_mask.sum().item() chunk_size = 256 total_positions = hidden.shape[0] * hidden.shape[1] hidden_flat = hidden.view(-1, hidden.shape[-1]) targets_flat = token_ids.view(-1) total_loss = torch.tensor(0.0, device=device) total_correct = 0 for i in range(0, total_positions, chunk_size): end = min(i + chunk_size, total_positions) h_chunk = hidden_flat[i:end] t_chunk = targets_flat[i:end] m_chunk = active_mask[i:end].float() w = model.output_proj.weight logits_chunk = F.linear(h_chunk, w) loss_chunk = F.cross_entropy(logits_chunk, t_chunk, reduction="none") total_loss = total_loss + (loss_chunk * m_chunk).sum() with torch.no_grad(): preds_chunk = logits_chunk.argmax(-1) total_correct += ((preds_chunk == t_chunk) * m_chunk.bool()).sum().item() loss = total_loss / max(total_active, 1) loss_weight = (1.0 / mask_ratio.squeeze(1)).mean() loss = (loss * loss_weight) / grad_accum # Gọi backward trực tiếp, không dùng scaler loss.backward() running_loss += loss.item() * grad_accum running_acc += total_correct / max(total_active, 1) running_count += 1 total_samples += token_ids.shape[0] micro_step += 1 if micro_step < grad_accum: continue # Bước Optimizer chuẩn: Clip -> Step micro_step = 0 nn.utils.clip_grad_norm_(model.parameters(), tc["max_grad_norm"]) optimizer.step() with torch.no_grad(): for ep, mp in zip(ema_model.parameters(), model.parameters()): ep.mul_(ema_decay).add_(mp, alpha=1 - ema_decay) step += 1 if step % log_every == 0: avg_loss = running_loss / running_count avg_acc = running_acc / running_count elapsed = (time.time() - t0_global) / 60 rate = total_samples / (time.time() - t0_global) print(f"step {step} | loss {avg_loss:.4f} | acc {avg_acc:.3f} | lr {lr:.2e} | {rate:.0f} samp/s | {elapsed:.1f}m", flush=True) running_loss, running_acc, running_count = 0.0, 0.0, 0 def main(): parser = argparse.ArgumentParser() parser.add_argument("--config", default="configs/v2_qwen3.yaml") parser.add_argument("--resume", action="store_true") args = parser.parse_args() with open(args.config) as f: config = yaml.safe_load(f) config["_ckpt_dir"] = f"checkpoints_{os.path.splitext(os.path.basename(args.config))[0]}" train(config, resume=args.resume) if __name__ == "__main__": main()