#!/usr/bin/env python # encoding: utf-8 import argparse import json import os import sys import time import torch sys.path.append(".") from fastreid.config import get_cfg from fastreid.data import build_reid_train_loader from fastreid.modeling import build_model from fastreid.solver import build_lr_scheduler, build_optimizer from fastreid.utils.checkpoint import Checkpointer from fastreid.utils.events import EventStorage def setup(args): cfg = get_cfg() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.defrost() if args.output_dir: cfg.OUTPUT_DIR = args.output_dir if args.max_epoch is not None: cfg.SOLVER.MAX_EPOCH = args.max_epoch if args.batch_size is not None: cfg.SOLVER.IMS_PER_BATCH = args.batch_size if args.num_workers is not None: cfg.DATALOADER.NUM_WORKERS = args.num_workers cfg.MODEL.BACKBONE.PRETRAIN = False cfg.freeze() return cfg def write_jsonl(path, payload): with open(path, "a") as handle: handle.write(json.dumps(payload, sort_keys=True) + "\n") def main(args): cfg = setup(args) os.makedirs(cfg.OUTPUT_DIR, exist_ok=True) data_loader = build_reid_train_loader(cfg, combineall=cfg.DATASETS.COMBINEALL) cfg.defrost() cfg.MODEL.HEADS.NUM_CLASSES = data_loader.dataset.num_classes cfg.freeze() model = build_model(cfg) # AMP needs standard parameter groups and must unscale gradients before clipping. optimizer_cfg = cfg.clone() optimizer_cfg.defrost() optimizer_cfg.SOLVER.CLIP_GRADIENTS.ENABLED = False optimizer_cfg.freeze() optimizer, _ = build_optimizer(optimizer_cfg, model, contiguous=False) iters_per_epoch = max(len(data_loader.dataset) // cfg.SOLVER.IMS_PER_BATCH, 1) schedulers = build_lr_scheduler(cfg, optimizer, iters_per_epoch) amp_enabled = bool(cfg.SOLVER.AMP.ENABLED and torch.cuda.is_available()) grad_scaler = torch.amp.GradScaler("cuda", enabled=amp_enabled) checkpointer = Checkpointer( model, cfg.OUTPUT_DIR, optimizer=optimizer, grad_scaler=grad_scaler, **schedulers, ) resuming = args.resume and checkpointer.has_checkpoint() checkpoint = checkpointer.resume_or_load(cfg.MODEL.WEIGHTS, resume=args.resume) if not resuming: # VDT's head was trained on global_feat - view_feat. CAVI uses a CLS-only # feature space, so inheriting that classifier and BNNeck is invalid. model.heads.reset_parameters() model.train() max_epoch = cfg.SOLVER.MAX_EPOCH full_max_iter = max_epoch * iters_per_epoch max_iter = min(full_max_iter, args.max_iter) if args.max_iter > 0 else full_max_iter if resuming: fallback_iteration = (int(checkpoint.get("epoch", -1)) + 1) * iters_per_epoch iteration = int(checkpoint.get("iteration", fallback_iteration)) else: iteration = 0 start_epoch = iteration // iters_per_epoch if iteration >= max_iter: raise ValueError( f"Resume position iter={iteration} is not below requested max_iter={max_iter}" ) metrics_path = os.path.join(cfg.OUTPUT_DIR, "metrics.jsonl") start = time.time() last_saved_epoch = start_epoch warmup_iters = cfg.SOLVER.WARMUP_ITERS delay_epochs = cfg.SOLVER.DELAY_EPOCHS with EventStorage(iteration) as storage: try: while iteration < max_iter: epoch = min(iteration // iters_per_epoch, max_epoch - 1) storage.epoch = epoch for data in data_loader: if iteration >= max_iter: break epoch = min(iteration // iters_per_epoch, max_epoch - 1) storage.epoch = epoch storage.iter = iteration with torch.amp.autocast("cuda", enabled=amp_enabled): losses = model(data) total_loss = sum(losses.values()) if not torch.isfinite(total_loss).all(): raise FloatingPointError(f"Non-finite loss at iter {iteration}: {losses}") optimizer.zero_grad() grad_scaler.scale(total_loss).backward() grad_scaler.unscale_(optimizer) if cfg.SOLVER.CLIP_GRADIENTS.ENABLED: clip_cfg = cfg.SOLVER.CLIP_GRADIENTS if clip_cfg.CLIP_TYPE == "norm": torch.nn.utils.clip_grad_norm_( model.parameters(), clip_cfg.CLIP_VALUE, clip_cfg.NORM_TYPE ) elif clip_cfg.CLIP_TYPE == "value": torch.nn.utils.clip_grad_value_(model.parameters(), clip_cfg.CLIP_VALUE) else: raise ValueError(f"Unknown gradient clip type: {clip_cfg.CLIP_TYPE}") scale_before_step = grad_scaler.get_scale() grad_scaler.step(optimizer) grad_scaler.update() optimizer_step_succeeded = grad_scaler.get_scale() >= scale_before_step if optimizer_step_succeeded: # GradScaler can bypass the marker installed by PyTorch schedulers. # Set it only after a successful optimizer update. optimizer._opt_called = True if iteration % args.log_period == 0: row = { "epoch": epoch, "iter": iteration, "max_iter": max_iter, "lr": optimizer.param_groups[0]["lr"], "amp_scale": grad_scaler.get_scale(), "optimizer_step": int(optimizer_step_succeeded), "total_loss": float(total_loss.detach().cpu()), "time_sec": round(time.time() - start, 2), } for key, value in losses.items(): row[key] = float(value.detach().cpu()) for key, value in getattr(model, "latest_cavi_metrics", {}).items(): row[key] = float(value.cpu()) print(json.dumps(row, sort_keys=True), flush=True) write_jsonl(metrics_path, row) iteration += 1 if ( optimizer_step_succeeded and iteration <= warmup_iters and "warmup_sched" in schedulers ): schedulers["warmup_sched"].step() completed_epoch = iteration // iters_per_epoch at_epoch_boundary = iteration % iters_per_epoch == 0 if ( at_epoch_boundary and optimizer_step_succeeded and iteration > warmup_iters and completed_epoch > delay_epochs ): schedulers["lr_sched"].step() if ( at_epoch_boundary and completed_epoch > last_saved_epoch and completed_epoch % args.checkpoint_period == 0 ): checkpointer.save( f"model_epoch_{completed_epoch}", epoch=completed_epoch - 1, iteration=iteration, ) last_saved_epoch = completed_epoch finally: if hasattr(data_loader, "shutdown"): data_loader.shutdown() final_epoch = min(max(iteration - 1, 0) // iters_per_epoch, max_epoch - 1) checkpointer.save("model_final", epoch=final_epoch, iteration=iteration) print(f"Training finished at iter={iteration}, output={cfg.OUTPUT_DIR}", flush=True) def parse_args(): parser = argparse.ArgumentParser(description="CAVI trainer with explicit iteration bounds") parser.add_argument("--config-file", required=True) parser.add_argument("--resume", action="store_true") parser.add_argument("--output-dir", default=None) parser.add_argument("--max-epoch", type=int, default=None) parser.add_argument("--max-iter", type=int, default=0) parser.add_argument("--batch-size", type=int, default=None) parser.add_argument("--num-workers", type=int, default=None) parser.add_argument("--log-period", type=int, default=20) parser.add_argument("--checkpoint-period", type=int, default=1) parser.add_argument("opts", nargs=argparse.REMAINDER) return parser.parse_args() if __name__ == "__main__": main(parse_args())