tools/train_cavi_noeval.py

#!/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())