trainer/build.py

import copy as cp
import glob
from datetime import timedelta
from pathlib import Path
from omegaconf import OmegaConf
from omegaconf import open_dict
from tqdm import tqdm
import numpy as np

from accelerate import Accelerator, DistributedDataParallelKwargs
from accelerate.logging import get_logger
from accelerate.utils import set_seed, InitProcessGroupKwargs
from fvcore.common.registry import Registry
import torch
import wandb

import common.io_utils as iu
from common.io_utils import make_dir
import common.misc as misc
from data.build import build_dataloader
from evaluator.build import build_eval
from model.build import build_model
from optim.build import build_optim
from safetensors.torch import load_file

TRAINER_REGISTRY = Registry("Trainer")


def _global_l2(tensors):
    """Compute sqrt(Σ‖t‖₂²) over an iterable of tensors."""
    total_sq = torch.tensor(0.0)
    for t in tensors:
        total_sq += t.float().pow(2).sum()
    return total_sq.sqrt()


class Tracker():
    def __init__(self, cfg):
        self.reset(cfg)

    def step(self):
        self.epoch += 1

    def reset(self, cfg):
        self.exp_name = f"{cfg.exp_dir.parent.name.replace(f'{cfg.name}', '').lstrip('_')}/{cfg.exp_dir.name}"
        self.epoch = 0
        self.best_result = -np.inf

    def state_dict(self):
        return {k: v for k, v in self.__dict__.items() if not k.startswith('__')}
    
    def load_state_dict(self, state_dict):
        self.__dict__.update(state_dict)

@TRAINER_REGISTRY.register()
class BaseTrainer():
    def __init__(self, cfg):
        set_seed(cfg.rng_seed)
        self.debug = cfg.debug.get("flag", False)
        self.hard_debug = cfg.debug.get("hard_debug", False)
        self.epochs_per_eval = cfg.solver.get("epochs_per_eval", None)
        self.epochs_per_save = cfg.solver.get("epochs_per_save", None)
        self.global_step = 0
        
        # Initialize accelerator
        self.exp_tracker = Tracker(cfg)
        wandb_args = {"entity": cfg.logger.entity, "id": cfg.logger.run_id, "resume": cfg.resume}
        if not cfg.logger.get('autoname'):
            wandb_args["name"] = self.exp_tracker.exp_name
        # There is bug in logger setting, needs fixing from accelerate side
        self.logger = get_logger(__name__)
        self.mode = cfg.mode

        ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
        init_kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=5400))
        kwargs = ([ddp_kwargs] if cfg.num_gpu > 1 else []) + [init_kwargs]

        gradient_accumulation_steps = cfg.solver.get("gradient_accumulation_steps", 1)
   
        self.accelerator = Accelerator(
            gradient_accumulation_steps=gradient_accumulation_steps,
            log_with=cfg.logger.name,
            kwargs_handlers=kwargs
        )
        
        if not self.hard_debug:
            self.accelerator.init_trackers(
                    project_name=cfg.name if not self.debug else "Debug",
                    config=OmegaConf.to_container(cfg, resolve=True, throw_on_missing=True) if not cfg.resume else None,
                    init_kwargs={"wandb": wandb_args}
                )
            
        print(OmegaConf.to_yaml(cfg))

        if cfg.model.name == 'Query3D':
            # choose whether to load mv or voxel features based on model.memories for Query3D
            # TODO: a better way to do this?
            if 'mv' in cfg.model.memories or 'sem' in cfg.model.memories:
                cfg.data.load_multiview_info = True
            if 'voxel' in cfg.model.memories or 'sem' in cfg.model.memories:
                cfg.data.load_mask3d_voxel = True
            txt_model2tokenizer = {'BERTLanguageEncoder': 'bert-base-uncased', 'CLIPLanguageEncoder': 'openai/clip-vit-large-patch14'}
            cfg.data_wrapper.tokenizer = txt_model2tokenizer[cfg.model.txt_encoder.name]
            
        if self.mode in ["warmup", "pretrain"]:
            keys = [self.mode]
        else:
            keys = ["train", "val", "test"] 
            
        self.data_loaders = {key : build_dataloader(cfg, split=key) for key in keys}
        self.model = build_model(cfg)
        
        if self.mode == 'warmup':
            self.epochs = cfg.solver.warmup_epochs
        else:
            self.epochs = cfg.solver.epochs
            
        if self.mode == "test":
            total_steps = 1
        else:
            total_steps = (len(self.data_loaders[self.mode]) * self.epochs) // gradient_accumulation_steps
        self.loss, self.optimizer, self.scheduler = build_optim(cfg, self.model.get_opt_params(),
                                                                total_steps= total_steps, accelerator = self.accelerator)
        
        if misc.rgetattr(cfg, "eval.pass_kwargs", False):
            kwargs = {"dataloaders": self.data_loaders}
        else:
            kwargs = {}
        self.evaluator = build_eval(cfg, self.accelerator, **kwargs)

        # Training details
        
        self.total_steps = 1 if self.mode == "test" else len(self.data_loaders[self.mode]) * self.epochs
        self.grad_norm = cfg.solver.get("grad_norm")

        ema = [0.996, 1.0]
        ipe_scale = 1.0
        self.momentum_scheduler = (ema[0] + i*(ema[1]-ema[0])/(self.total_steps*self.epochs*ipe_scale)
                          for i in range(int(self.total_steps*self.epochs*ipe_scale)+1))
        
        # Load pretrain model weights
        if cfg.get('pretrain_ckpt_path'):
            self.pretrain_ckpt_path = Path(cfg.pretrain_ckpt_path)
            self.load_pretrain()
            if hasattr(self.model, "pm_encoder"):
                self.model.pm_encoder.load_state_dict(self.model.pm_encoder.state_dict())

        # Accelerator preparation
        self.model, self.loss, self.optimizer, self.scheduler = self.accelerator.prepare(self.model, self.loss, self.optimizer, self.scheduler)
        for name, loader in self.data_loaders.items():
            if isinstance(loader, list):
                loader = self.accelerator.prepare(*loader)
            else:
                loader = self.accelerator.prepare(loader)
            self.data_loaders[name] = loader
        self.accelerator.register_for_checkpointing(self.exp_tracker)

        # Check if resuming from previous checkpoint is needed
        self.ckpt_path = Path(cfg.ckpt_path) if cfg.get("ckpt_path") else Path(cfg.exp_dir) / "ckpt" / "best.pth"
        if cfg.resume:
            self.resume()

    def forward(self, data_dict):
        return self.model(data_dict)

    def update_ema(self):
        # Update the momentum scheduler 
        with torch.no_grad():
            m = next(self.momentum_scheduler)
            # Automatically handle .module for DDP
            model_context = self.model.module.context_model if hasattr(self.model, 'module') else self.model.context_model
            model_target = self.model.module.target_model if hasattr(self.model, 'module') else self.model.target_model

            for param_q, param_k in zip(model_context.parameters(), model_target.parameters()):
                param_k.data.mul_(m).add_((1. - m) * param_q.detach().data)
                
    def backward(self, loss):
        # Backprop
        self.accelerator.backward(loss)

        total_norm = torch.norm(torch.stack([
            torch.norm(p.grad.detach()) for p in self.model.parameters() if p.grad is not None
        ]))
        print(f"grad_norm={total_norm.item():.2f}")
        
        # Gradient clipping (only when syncing gradients)
        if self.grad_norm is not None and self.accelerator.sync_gradients:
            self.accelerator.clip_grad_norm_(self.model.parameters(), self.grad_norm)

        # Optimizer step only when syncing gradients
        if self.accelerator.sync_gradients:
            self.optimizer.step()
            self.optimizer.zero_grad()
            self.scheduler.step()

    def log(self, results, mode="train"):
        if not self.hard_debug:
            log_dict = {}
            for key, val in results.items():
                if isinstance(val, torch.Tensor):
                    val = val.item()
                log_dict[f"{mode}/{key}"] = val
            if mode == "train":
                lrs = self.scheduler.get_lr()
                for i, lr in enumerate(lrs):
                    log_dict[f"{mode}/lr/group_{i}"] = lr
            self.accelerator.log(log_dict, step=self.global_step)

    def save(self, name):
        make_dir(self.ckpt_path.parent)
        self.save_func(str(self.ckpt_path.parent / name))

    def resume(self):
        if self.ckpt_path.exists():
            print(f"Resuming from {str(self.ckpt_path)}")
            # self.logger.info(f"Resuming from {str(self.ckpt_path)}")
            self.accelerator.load_state(str(self.ckpt_path))
            # self.logger.info(f"Successfully resumed from {self.ckpt_path}")
            print(f"Successfully resumed from {self.ckpt_path}")
        else:
            self.logger.info("training from scratch")
    
    def load_pretrain(self):
        print(f"📂 Loading pretrained weights from: {str(self.pretrain_ckpt_path)}")
        model_weight_path_pattern = str(self.pretrain_ckpt_path / "model*.safetensors")
        model_weight_paths = glob.glob(model_weight_path_pattern)

        if len(model_weight_paths) == 0:
            raise FileNotFoundError(f"❌ Cannot find any .safetensors file in {str(self.pretrain_ckpt_path)}")

        # Load and merge weights
        weights = {}
        for model_weight_path in model_weight_paths:
            weights.update(load_file(model_weight_path, device="cpu"))

        # Load weights with strict=False
        result = self.model.load_state_dict(weights, strict=False)
        
        model_keys = set(self.model.state_dict().keys())
        loaded_keys = model_keys.intersection(weights.keys())
        missing_keys = result.missing_keys
        unexpected_keys = result.unexpected_keys
        print(missing_keys)
        print(f"✅ Loaded keys:      {len(loaded_keys)} / {len(model_keys)}")
        print(f"❌ Missing keys:     {len(missing_keys)}")
        print(f"⚠️ Unexpected keys:  {len(unexpected_keys)}")
        
    def save_func(self, path):
        self.accelerator.save_state(path)
    
def build_trainer(cfg):
    return TRAINER_REGISTRY.get(cfg.trainer)(cfg)