train.py

#!/usr/bin/env python
""" EfficientDet Training Script

This script was started from an early version of the PyTorch ImageNet example
(https://github.com/pytorch/examples/tree/master/imagenet)

NVIDIA CUDA specific speedups adopted from NVIDIA Apex examples
(https://github.com/NVIDIA/apex/tree/master/examples/imagenet)

Hacked together by Ross Wightman (https://github.com/rwightman)
"""
import argparse
import logging
import os
import time
import warnings
from collections import OrderedDict
from contextlib import suppress
from datetime import datetime
from pathlib import Path
from types import SimpleNamespace

import torch
import torchvision.utils
import yaml
from ray.air import session
from torch.nn.parallel import DistributedDataParallel as NativeDDP
from torch.utils.tensorboard import SummaryWriter

os.environ["CUDA_VISIBLE_DEVICES"] = "0"

try:
    from apex import amp
    from apex.parallel import DistributedDataParallel as ApexDDP
    from apex.parallel import convert_syncbn_model

    has_apex = True
except ImportError:
    has_apex = False

has_native_amp = False
try:
    if getattr(torch.cuda.amp, "autocast") is not None:
        has_native_amp = True
except AttributeError:
    pass

import timm.utils as utils
from timm.models import load_checkpoint, resume_checkpoint
from timm.optim import create_optimizer
from timm.scheduler import create_scheduler

try:
    # new timm import
    from timm.layers import convert_sync_batchnorm, set_layer_config
except ImportError:
    # support several versions back in timm
    from timm.models.layers import set_layer_config

    try:
        # timm has its own convert_sync_bn to support BatchNormAct layers in updated models
        from timm.models.layers import convert_sync_batchnorm
    except ImportError:
        warnings.warn(
            "Falling back to torch.nn.SyncBatchNorm, does not properly work with timm models in new versions."
        )
        convert_sync_batchnorm = torch.nn.SyncBatchNorm.convert_sync_batchnorm

from effdet import (
    create_dataset,
    create_evaluator,
    create_loader,
    create_model,
    unwrap_bench,
)
from effdet.anchors import AnchorLabeler, Anchors
from effdet.data import SkipSubset, resolve_input_config, transforms

torch.backends.cudnn.benchmark = True


# The first arg parser parses out only the --config argument, this argument is used to
# load a yaml file containing key-values that override the defaults for the main parser below
config_parser = parser = argparse.ArgumentParser(
    description="Training Config", add_help=False
)
parser.add_argument(
    "-c",
    "--config",
    default="",
    type=str,
    metavar="FILE",
    help="YAML config file specifying default arguments",
)


parser = argparse.ArgumentParser(description="PyTorch ImageNet Training")
# Dataset / Model parameters
parser.add_argument("root", metavar="DIR", help="path to dataset")
parser.add_argument(
    "--dataset",
    default="depthpose",
    type=str,
    metavar="DATASET",
    help='Name of dataset to train (default: "poseme"',
)
parser.add_argument(
    "--model",
    default="tf_efficientdet_d1",
    type=str,
    metavar="MODEL",
    help='Name of model to train (default: "tf_efficientdet_d1"',
)
utils.add_bool_arg(
    parser,
    "redundant-bias",
    default=None,
    help="override model config for redundant bias",
)
utils.add_bool_arg(
    parser, "soft-nms", default=None, help="override model config for soft-nms"
)
parser.add_argument(
    "--val-skip",
    type=int,
    default=0,
    metavar="N",
    help="Skip every N validation samples.",
)
parser.add_argument(
    "--num-classes",
    type=int,
    default=None,
    metavar="N",
    help="Override num_classes in model config if set. For fine-tuning from pretrained.",
)
parser.add_argument(
    "--pretrained",
    action="store_true",
    default=False,
    help="Start with pretrained version of specified network (if avail)",
)
parser.add_argument(
    "--no-pretrained-backbone",
    action="store_true",
    default=False,
    help="Do not start with pretrained backbone weights, fully random.",
)
parser.add_argument(
    "--initial-checkpoint",
    default="",
    type=str,
    metavar="PATH",
    help="Initialize model from this checkpoint (default: none)",
)
parser.add_argument(
    "--resume",
    default="",
    type=str,
    metavar="PATH",
    help="Resume full model and optimizer state from checkpoint (default: none)",
)
parser.add_argument(
    "--no-resume-opt",
    action="store_true",
    default=False,
    help="prevent resume of optimizer state when resuming model",
)
parser.add_argument(
    "--mean",
    type=float,
    nargs="+",
    default=None,
    metavar="MEAN",
    help="Override mean pixel value of dataset",
)
parser.add_argument(
    "--std",
    type=float,
    nargs="+",
    default=None,
    metavar="STD",
    help="Override std deviation of of dataset",
)
parser.add_argument(
    "--interpolation",
    default="",
    type=str,
    metavar="NAME",
    help="Image resize interpolation type (overrides model)",
)
parser.add_argument(
    "--fill-color",
    default=None,
    type=str,
    metavar="NAME",
    help='Image augmentation fill (background) color ("mean" or int)',
)
parser.add_argument(
    "-b",
    "--batch-size",
    type=int,
    default=2,
    metavar="N",
    help="input batch size for training (default: 32)",
)
parser.add_argument(
    "--clip-grad",
    type=float,
    default=10.0,
    metavar="NORM",
    help="Clip gradient norm (default: 10.0)",
)
parser.add_argument(
    "--clip-mode",
    type=str,
    default="norm",
    help='Gradient clipping mode. One of ("norm", "value", "agc")',
)

# Optimizer parameters
parser.add_argument(
    "--opt",
    default="momentum",
    type=str,
    metavar="OPTIMIZER",
    help='Optimizer (default: "momentum"',
)
parser.add_argument(
    "--opt-eps",
    default=1e-3,
    type=float,
    metavar="EPSILON",
    help="Optimizer Epsilon (default: 1e-3)",
)
parser.add_argument(
    "--momentum",
    type=float,
    default=0.9,
    metavar="M",
    help="SGD momentum (default: 0.9)",
)
parser.add_argument(
    "--weight-decay", type=float, default=4e-5, help="weight decay (default: 0.00004)"
)

# Learning rate schedule parameters
parser.add_argument(
    "--sched",
    default="cosine",
    type=str,
    metavar="SCHEDULER",
    help='LR scheduler (default: "step"',
)
parser.add_argument(
    "--lr", type=float, default=0.01, metavar="LR", help="learning rate (default: 0.01)"
)
parser.add_argument(
    "--lr-noise",
    type=float,
    nargs="+",
    default=None,
    metavar="pct, pct",
    help="learning rate noise on/off epoch percentages",
)
parser.add_argument(
    "--lr-noise-pct",
    type=float,
    default=0.67,
    metavar="PERCENT",
    help="learning rate noise limit percent (default: 0.67)",
)
parser.add_argument(
    "--lr-noise-std",
    type=float,
    default=1.0,
    metavar="STDDEV",
    help="learning rate noise std-dev (default: 1.0)",
)
parser.add_argument(
    "--lr-cycle-mul",
    type=float,
    default=1.0,
    metavar="MULT",
    help="learning rate cycle len multiplier (default: 1.0)",
)
parser.add_argument(
    "--lr-cycle-limit",
    type=int,
    default=1,
    metavar="N",
    help="learning rate cycle limit",
)
parser.add_argument(
    "--warmup-lr",
    type=float,
    default=0.0001,
    metavar="LR",
    help="warmup learning rate (default: 0.0001)",
)
parser.add_argument(
    "--min-lr",
    type=float,
    default=1e-5,
    metavar="LR",
    help="lower lr bound for cyclic schedulers that hit 0 (1e-5)",
)
parser.add_argument(
    "--epochs",
    type=int,
    default=200,
    metavar="N",
    help="number of epochs to train (default: 2)",
)
parser.add_argument(
    "--start-epoch",
    default=None,
    type=int,
    metavar="N",
    help="manual epoch number (useful on restarts)",
)
parser.add_argument(
    "--decay-epochs",
    type=float,
    default=30,
    metavar="N",
    help="epoch interval to decay LR",
)
parser.add_argument(
    "--warmup-epochs",
    type=int,
    default=5,
    metavar="N",
    help="epochs to warmup LR, if scheduler supports",
)
parser.add_argument(
    "--cooldown-epochs",
    type=int,
    default=10,
    metavar="N",
    help="epochs to cooldown LR at min_lr, after cyclic schedule ends",
)
parser.add_argument(
    "--patience-epochs",
    type=int,
    default=10,
    metavar="N",
    help="patience epochs for Plateau LR scheduler (default: 10",
)
parser.add_argument(
    "--decay-rate",
    "--dr",
    type=float,
    default=0.1,
    metavar="RATE",
    help="LR decay rate (default: 0.1)",
)

# Augmentation parameters
parser.add_argument(
    "--color-jitter",
    type=float,
    default=0.4,
    metavar="PCT",
    help="Color jitter factor (default: 0.4)",
)
parser.add_argument(
    "--aa",
    type=str,
    default=None,
    metavar="NAME",
    help='Use AutoAugment policy. "v0" or "original". (default: None)',
),
parser.add_argument(
    "--reprob",
    type=float,
    default=0.0,
    metavar="PCT",
    help="Random erase prob (default: 0.)",
)
parser.add_argument(
    "--remode", type=str, default="pixel", help='Random erase mode (default: "pixel")'
)
parser.add_argument(
    "--recount", type=int, default=1, help="Random erase count (default: 1)"
)
parser.add_argument(
    "--train-interpolation",
    type=str,
    default="random",
    help='Training interpolation (random, bilinear, bicubic default: "random")',
)

# loss
parser.add_argument(
    "--smoothing",
    type=float,
    default=None,
    help="override model config label smoothing",
)
utils.add_bool_arg(
    parser,
    "jit-loss",
    default=None,
    help="override model config for torchscript jit loss fn",
)
utils.add_bool_arg(
    parser,
    "legacy-focal",
    default=None,
    help="override model config to use legacy focal loss",
)

# Model Exponential Moving Average
parser.add_argument(
    "--model-ema",
    action="store_true",
    default=False,
    help="Enable tracking moving average of model weights",
)
parser.add_argument(
    "--model-ema-decay",
    type=float,
    default=0.9998,
    help="decay factor for model weights moving average (default: 0.9998)",
)

# Misc
parser.add_argument(
    "--sync-bn",
    action="store_true",
    help="Enable NVIDIA Apex or Torch synchronized BatchNorm.",
)
parser.add_argument(
    "--dist-bn",
    type=str,
    default="",
    help='Distribute BatchNorm stats between nodes after each epoch ("broadcast", "reduce", or "")',
)
parser.add_argument(
    "--seed", type=int, default=42, metavar="S", help="random seed (default: 42)"
)
parser.add_argument(
    "--log-interval",
    type=int,
    default=50,
    metavar="N",
    help="how many batches to wait before logging training status",
)
parser.add_argument(
    "--recovery-interval",
    type=int,
    default=0,
    metavar="N",
    help="how many batches to wait before writing recovery checkpoint",
)
parser.add_argument(
    "-j",
    "--workers",
    type=int,
    default=4,
    metavar="N",
    help="how many training processes to use (default: 1)",
)
parser.add_argument(
    "--save-images",
    action="store_true",
    default=False,
    help="save images of input bathes every log interval for debugging",
)
parser.add_argument(
    "--amp",
    action="store_true",
    default=False,
    help="use NVIDIA Apex AMP or Native AMP for mixed precision training",
)
parser.add_argument(
    "--apex-amp",
    action="store_true",
    default=False,
    help="Use NVIDIA Apex AMP mixed precision",
)
parser.add_argument(
    "--native-amp",
    action="store_true",
    default=False,
    help="Use Native Torch AMP mixed precision",
)
parser.add_argument(
    "--channels-last",
    action="store_true",
    default=False,
    help="Use channels_last memory layout",
)
parser.add_argument(
    "--pin-mem",
    action="store_true",
    default=False,
    help="Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU.",
)
parser.add_argument(
    "--no-prefetcher",
    action="store_true",
    default=False,
    help="disable fast prefetcher",
)
parser.add_argument(
    "--torchscript",
    dest="torchscript",
    action="store_true",
    help="convert model torchscript for inference",
)
parser.add_argument(
    "--torchcompile",
    nargs="?",
    type=str,
    default=None,
    const="inductor",
    help="Enable compilation w/ specified backend (default: inductor).",
)
utils.add_bool_arg(
    parser,
    "bench-labeler",
    default=False,
    help="label targets in model bench, increases GPU load at expense of loader processes",
)
parser.add_argument(
    "--output",
    default="./output",
    type=str,
    metavar="PATH",
    help="path to output folder (default: none, current dir)",
)
parser.add_argument(
    "--eval-metric",
    default="map",
    type=str,
    metavar="EVAL_METRIC",
    help='Best metric (default: "map"',
)
parser.add_argument(
    "--tta",
    type=int,
    default=0,
    metavar="N",
    help="Test/inference time augmentation (oversampling) factor. 0=None (default: 0)",
)
parser.add_argument("--local_rank", default=0, type=int)

# EfficientPose architecture options
utils.add_bool_arg(
    parser,
    "combined-t-head",
    default=False,
    help="Use combined head for xy and z regression",
)
utils.add_bool_arg(
    parser,
    "iterative-pose-heads",
    default=False,
    help="Use iterative heads for rotation and translation.",
)
utils.add_bool_arg(
    parser,
    "axis-angle",
    default=False,
    help="Use axis angle instead of 6D rotation representation.",
)


# EfficientPose loss options
utils.add_bool_arg(
    parser,
    "mean-dist-z",
    default=False,
    help="Use mean distance weighted z loss.",
)
utils.add_bool_arg(
    parser,
    "mean-dist-rot",
    default=False,
    help="Use mean distance weighted z loss.",
)
parser.add_argument(
    "--box-loss-weight",
    type=float,
    default=50.0,
    help="Weight of the Box Loss (default: 50).",
)
parser.add_argument(
    "--rot-loss-weight",
    type=float,
    default=500.0,
    help="Weight of the Rotation Loss (default: 500).",
)
parser.add_argument(
    "--xy-loss-weight",
    type=float,
    default=50.0,
    help="Weight of the XY Loss (default: 50).",
)
parser.add_argument(
    "--z-loss-weight",
    type=float,
    default=250.0,
    help="Weight of the XY Loss (default: 250).",
)


# EfficientPose IoU options
parser.add_argument(
    "--labeler-iou",
    type=float,
    default=0.5,
    help="IoU threshold of the anchor target labeler (default: 0.5).",
)
parser.add_argument(
    "--detection-iou",
    type=float,
    default=0.5,
    help="IoU threshold for the NMS of the detections (default: 0.5).",
)

# EfficientPose Augmentations
utils.add_bool_arg(
    parser,
    "mask-aug",
    default=False,
    help="Enable Mask and Threshold augmentations (train and eval).",
)
utils.add_bool_arg(
    parser,
    "color-aug",
    default=False,
    help="Enable color space augmentations (only train).",
)
utils.add_bool_arg(
    parser,
    "rot-aug",
    default=False,
    help="6D Augmentation - Enable stepped rot augmentation (only train).",
)
utils.add_bool_arg(
    parser,
    "z-aug",
    default=False,
    help="6D Augmentation - Enable Z augmentation (only train).",
)
parser.add_argument(
    "--z-aug-min",
    type=float,
    default=0.9,
    help="6D Augmentation - MIN scale factor (default: 0.9).",
)
parser.add_argument(
    "--z-aug-max",
    type=float,
    default=1.2,
    help="6D Augmentation - MAX scale factor (default: 1.2).",
)


def _parse_args():
    # Do we have a config file to parse?
    args_config, remaining = config_parser.parse_known_args()
    if args_config.config:
        with open(args_config.config, "r") as f:
            cfg = yaml.safe_load(f)
            parser.set_defaults(**cfg)

    # The main arg parser parses the rest of the args, the usual
    # defaults will have been overridden if config file specified.
    args = parser.parse_args(remaining)
    return args


def _get_args_text(args):
    # Cache the args as a text string to save them in the output dir later
    args_text = yaml.safe_dump(args.__dict__, default_flow_style=False)
    return args_text


def get_clip_parameters(model, exclude_head=False):
    if exclude_head:
        # FIXME this a bit of a quick and dirty hack to skip classifier head params
        return [p for n, p in model.named_parameters() if "predict" not in n]
    else:
        return model.parameters()


def log_hparams(writer: SummaryWriter, params: dict):
    for k, v in params.items():
        if isinstance(v, (int, float)):
            writer.add_scalar(f"hparams/{k}", v)
        else:
            writer.add_text(f"hparams/{k}", str(v))


def create_transforms(args):
    if args.mean_dist_z and args.z_aug:
        raise ValueError("Cannot use Z-Aug with Mean Distance Weighted Loss.")
    if args.mean_dist_rot and args.rot_aug:
        raise ValueError("Cannot use Rot-Aug with Mean Distance Weighted Loss.")
    if args.mean_dist_rot and args.axis_angle:
        raise NotImplementedError("No Mean Distance Weighted Loss for Axis-Angle")

    transform_train = transforms.build_imagepose_transform(
        args.mask_aug,
        args.color_aug,
        args.rot_aug,
        args.z_aug,
        args.z_aug_min,
        args.z_aug_max,
    )
    transform_eval = transforms.build_imagepose_transform(args.mask_aug)
    return transform_train, transform_eval


def train(args):
    if isinstance(args, dict):
        # This makes the dict items accessible via dot notation.
        # Only really needed if train is called with a dictionary instead
        # of the parser output directly.
        args = SimpleNamespace(**args)

    utils.setup_default_logging()
    args_text = _get_args_text(args)

    args.pretrained_backbone = not args.no_pretrained_backbone
    args.prefetcher = not args.no_prefetcher
    args.distributed = False
    if "WORLD_SIZE" in os.environ:
        args.distributed = int(os.environ["WORLD_SIZE"]) > 1
    args.device = "cuda:0"
    args.world_size = 1
    args.rank = 0  # global rank
    if args.distributed:
        args.device = "cuda:%d" % args.local_rank
        torch.cuda.set_device(args.local_rank)
        torch.distributed.init_process_group(backend="nccl", init_method="env://")
        args.world_size = torch.distributed.get_world_size()
        args.rank = torch.distributed.get_rank()
    assert args.rank >= 0

    if args.distributed:
        logging.info(
            "Training in distributed mode with multiple processes, 1 GPU per process. Process %d, total %d."
            % (args.rank, args.world_size)
        )
    else:
        logging.info("Training with a single process on 1 GPU.")

    use_amp = None
    if args.amp:
        # for backwards compat, `--amp` arg tries apex before native amp
        if has_native_amp:
            args.native_amp = True
        elif has_apex:
            args.apex_amp = True
        else:
            logging.warning(
                "Neither APEX or native Torch AMP is available, using float32. "
                "Install NVIDA apex or upgrade to PyTorch 1.6."
            )

    if args.native_amp:
        if has_native_amp:
            use_amp = "native"
        else:
            logging.warning(
                "Native AMP not available, using float32. Upgrade to PyTorch 1.6."
            )
    elif args.apex_amp:
        if has_apex:
            use_amp = "apex"
        else:
            logging.warning("APEX AMP not available, using float32. Install NVIDA apex")

    utils.random_seed(args.seed, args.rank)

    # NOTE: Use sparingly, this is not the nicest way to implement
    #       dataset-specific adaptations. Could/should be refactored.
    config_overrides = {}
    if args.dataset == "imagepose":
        config_overrides["box_loss_weight"] = args.box_loss_weight
        config_overrides["txy_loss_weight"] = args.xy_loss_weight
        config_overrides["tz_loss_weight"] = args.z_loss_weight
        config_overrides["rot_loss_weight"] = args.rot_loss_weight

    with set_layer_config(scriptable=args.torchscript):
        model = create_model(
            args.model,
            bench_task="train",
            num_classes=args.num_classes,
            pretrained=args.pretrained,
            pretrained_backbone=args.pretrained_backbone,
            redundant_bias=args.redundant_bias,
            label_smoothing=args.smoothing,
            legacy_focal=args.legacy_focal,
            jit_loss=args.jit_loss,
            soft_nms=args.soft_nms,
            bench_labeler=args.bench_labeler,
            checkpoint_path=args.initial_checkpoint,
            config_overrides=config_overrides,
            combined_t_head=args.combined_t_head,
            iterative_pose_heads=args.iterative_pose_heads,
            axis_angle=args.axis_angle,
            mean_dist_z=args.mean_dist_z,
            mean_dist_rot=args.mean_dist_rot,
            detection_iou=args.detection_iou,
        )
    model_config = model.config  # grab before we obscure with DP/DDP wrappers

    if args.local_rank == 0:
        logging.info(
            "Model %s created, param count: %d"
            % (args.model, sum([m.numel() for m in model.parameters()]))
        )

    model.cuda()
    if args.channels_last:
        model = model.to(memory_format=torch.channels_last)

    if args.distributed and args.sync_bn:
        if has_apex and use_amp == "apex":
            model = convert_syncbn_model(model)
        else:
            # timm conversion fn that handles BatchNormAct2d layers
            model = convert_sync_batchnorm(model)
        if args.local_rank == 0:
            logging.info(
                "Converted model to use Synchronized BatchNorm. WARNING: You may have issues if using "
                "zero initialized BN layers (enabled by default for ResNets) while sync-bn enabled."
            )

    if args.torchscript:
        assert (
            not use_amp == "apex"
        ), "Cannot use APEX AMP with torchscripted model, force native amp with `--native-amp` flag"
        assert (
            not args.sync_bn
        ), "Cannot use SyncBatchNorm with torchscripted model. Use `--dist-bn reduce` instead of `--sync-bn`"
        model = torch.jit.script(model)
    elif args.torchcompile:
        # FIXME dynamo might need move below DDP wrapping? TBD
        model = torch.compile(model, backend=args.torchcompile)

    optimizer = create_optimizer(args, model)

    amp_autocast = suppress  # do nothing
    loss_scaler = None
    if use_amp == "native":
        amp_autocast = torch.cuda.amp.autocast
        loss_scaler = utils.NativeScaler()
        if args.local_rank == 0:
            logging.info("Using native Torch AMP. Training in mixed precision.")
    elif use_amp == "apex":
        model, optimizer = amp.initialize(model, optimizer, opt_level="O1")
        loss_scaler = utils.ApexScaler()
        if args.local_rank == 0:
            logging.info("Using NVIDIA APEX AMP. Training in mixed precision.")
    else:
        if args.local_rank == 0:
            logging.info("AMP not enabled. Training in float32.")

    # optionally resume from a checkpoint
    resume_epoch = None
    if args.resume:
        resume_epoch = resume_checkpoint(
            unwrap_bench(model),
            args.resume,
            optimizer=None if args.no_resume_opt else optimizer,
            loss_scaler=None if args.no_resume_opt else loss_scaler,
            log_info=args.local_rank == 0,
        )

    model_ema = None
    if args.model_ema:
        # Important to create EMA model after cuda(), DP wrapper, and AMP but before SyncBN and DDP wrapper
        model_ema = utils.ModelEmaV2(model, decay=args.model_ema_decay)
        if args.resume:
            load_checkpoint(unwrap_bench(model_ema), args.resume, use_ema=True)

    if args.distributed:
        if has_apex and use_amp == "apex":
            if args.local_rank == 0:
                logging.info("Using apex DistributedDataParallel.")
            model = ApexDDP(model, delay_allreduce=True)
        else:
            if args.local_rank == 0:
                logging.info("Using torch DistributedDataParallel.")
            model = NativeDDP(model, device_ids=[args.device])
        # NOTE: EMA model does not need to be wrapped by DDP...
        if model_ema is not None and not args.resume:
            # ...but it is a good idea to sync EMA copy of weights
            # NOTE: ModelEma init could be moved after DDP wrapper if using PyTorch DDP, not Apex.
            model_ema.set(model)

    lr_scheduler, num_epochs = create_scheduler(args, optimizer)
    start_epoch = 0
    if args.start_epoch is not None:
        # a specified start_epoch will always override the resume epoch
        start_epoch = args.start_epoch
    elif resume_epoch is not None:
        start_epoch = resume_epoch
    if lr_scheduler is not None and start_epoch > 0:
        lr_scheduler.step(start_epoch)

    if args.local_rank == 0:
        logging.info("Scheduled epochs: {}".format(num_epochs))

    transforms_train, transforms_eval = create_transforms(args)

    loader_train, loader_eval, evaluator = create_datasets_and_loaders(
        args, model_config, transforms_train, transforms_eval
    )

    if model_config.num_classes < loader_train.dataset.parser.max_label:
        logging.error(
            f"Model {model_config.num_classes} has fewer classes than dataset {loader_train.dataset.parser.max_label}."
        )
        exit(1)
    if model_config.num_classes > loader_train.dataset.parser.max_label:
        logging.warning(
            f"Model {model_config.num_classes} has more classes than dataset {loader_train.dataset.parser.max_label}."
        )

    eval_metric = args.eval_metric
    best_metric = None
    best_epoch = None
    saver = None
    writer = None
    output_dir = ""
    if args.local_rank == 0:
        if args.output:
            output_base = args.output
            output_base = Path(output_base).resolve().as_posix()  # workaround
            exp_name = "-".join([datetime.now().strftime("%Y%m%d-%H%M%S"), args.model])
            output_dir = utils.get_outdir(output_base, f"train_{args.dataset}", exp_name)
        else:
            output_dir = session.get_trial_dir()
        decreasing = True if eval_metric == "loss" else False
        saver = utils.CheckpointSaver(
            model,
            optimizer,
            args=args,
            model_ema=model_ema,
            amp_scaler=loss_scaler,
            checkpoint_dir=output_dir,
            decreasing=decreasing,
            unwrap_fn=unwrap_bench,
        )
        writer = SummaryWriter(os.path.join(output_dir, "tensorboard"))
        log_hparams(
            writer,
            {
                "model": args.model,
                "lr": args.lr,
                "epochs": args.epochs,
                "batch_size": args.batch_size,
                "sched": args.sched,
                "warmup_epochs": args.warmup_epochs,
                "warmup_lr": args.warmup_lr,
                "decay_epochs": args.decay_epochs,
                "decay_rate": args.decay_rate,
                "cooldown_epochs": args.cooldown_epochs,
                "min_lr": args.min_lr,
                "box_loss_weight": model_config.box_loss_weight,
                "rot_loss_weight": model_config.rot_loss_weight,
                "txy_loss_weight": model_config.txy_loss_weight,
                "tz_loss_weight": model_config.tz_loss_weight,
            },
        )

        with open(os.path.join(output_dir, "args.yaml"), "w") as f:
            f.write(args_text)

    try:
        for epoch in range(start_epoch, num_epochs):
            if args.distributed:
                loader_train.sampler.set_epoch(epoch)

            train_metrics = train_epoch(
                epoch,
                model,
                loader_train,
                optimizer,
                args,
                lr_scheduler=lr_scheduler,
                saver=saver,
                writer=writer,
                output_dir=output_dir,
                amp_autocast=amp_autocast,
                loss_scaler=loss_scaler,
                model_ema=model_ema,
            )

            if args.distributed and args.dist_bn in ("broadcast", "reduce"):
                if args.local_rank == 0:
                    logging.info("Distributing BatchNorm running means and vars")
                utils.distribute_bn(model, args.world_size, args.dist_bn == "reduce")

            # the overhead of evaluating with coco style datasets is fairly high, so just ema or non, not both
            if model_ema is not None:
                if args.distributed and args.dist_bn in ("broadcast", "reduce"):
                    utils.distribute_bn(
                        model_ema, args.world_size, args.dist_bn == "reduce"
                    )

                eval_metrics = validate(
                    model_ema.module, loader_eval, args, evaluator, log_suffix=" (EMA)"
                )
            else:
                eval_metrics = validate(model, loader_eval, args, evaluator)

            if lr_scheduler is not None:
                # step LR for next epoch
                lr_scheduler.step(epoch + 1, eval_metrics[eval_metric])

            if writer is not None:
                lrl = [param_group["lr"] for param_group in optimizer.param_groups]
                lr = sum(lrl) / len(lrl)
                writer.add_scalar("lr/train/epochs", lr, epoch)
                writer.add_scalar("loss/train/epochs", train_metrics["loss"], epoch)
                writer.add_scalar(
                    "loss_box_w/train/epochs", train_metrics["loss_box"], epoch
                )
                writer.add_scalar(
                    "loss_rot_w/train/epochs", train_metrics["loss_rot"], epoch
                )
                writer.add_scalar(
                    "loss_xy_w/train/epochs", train_metrics["loss_xy"], epoch
                )
                writer.add_scalar(
                    "loss_z_w/train/epochs", train_metrics["loss_z"], epoch
                )
                writer.add_scalar("loss/eval/epochs", eval_metrics["loss"], epoch)

                session.report(
                    {
                        "loss/train/epochs": train_metrics["loss"],
                        "loss_box_w/train/epochs": train_metrics["loss_box"],
                        "loss_rot_w/train/epochs": train_metrics["loss_rot"],
                        "loss_xy_w/train/epochs": train_metrics["loss_xy"],
                        "loss_z_w/train/epochs": train_metrics["loss_z"],
                        "loss/eval/epochs": eval_metrics["loss"],
                    }
                )

            if saver is not None:
                utils.update_summary(
                    epoch,
                    train_metrics,
                    eval_metrics,
                    os.path.join(output_dir, "summary.csv"),
                    write_header=best_metric is None,
                )

                # save proper checkpoint with eval metric
                best_metric, best_epoch = saver.save_checkpoint(
                    epoch=epoch, metric=eval_metrics[eval_metric]
                )

    except KeyboardInterrupt:
        pass

    if writer:
        writer.close()
    if best_metric is not None:
        logging.info("*** Best metric: {0} (epoch {1})".format(best_metric, best_epoch))


def create_datasets_and_loaders(
    args,
    model_config,
    transform_train_fn=None,
    transform_eval_fn=None,
    collate_fn=None,
):
    """Setup datasets, transforms, loaders, evaluator.

    Args:
        args: Command line args / config for training
        model_config: Model specific configuration dict / struct
        transform_train_fn: Override default image + annotation transforms (see note in loaders.py)
        transform_eval_fn: Override default image + annotation transforms (see note in loaders.py)
        collate_fn: Override default fast collate function

    Returns:
        Train loader, validation loader, evaluator
    """
    input_config = resolve_input_config(args, model_config=model_config)

    dataset_train, dataset_eval = create_dataset(args.dataset, args.root)

    # setup labeler in loader/collate_fn if not enabled in the model bench
    labeler = None
    if not args.bench_labeler:
        labeler = AnchorLabeler(
            Anchors.from_config(model_config),
            model_config.num_classes,
            # This IoU only applies to the labeler not `generate_detections()`.
            match_threshold=args.labeler_iou,  # Default: 0.5
            axis_angle=args.axis_angle,
        )

    loader_train = create_loader(
        dataset_train,
        input_size=input_config["input_size"],
        batch_size=args.batch_size,
        is_training=True,
        use_prefetcher=args.prefetcher,
        re_prob=args.reprob,
        re_mode=args.remode,
        re_count=args.recount,
        # color_jitter=args.color_jitter,
        # auto_augment=args.aa,
        interpolation=args.train_interpolation or input_config["interpolation"],
        fill_color=input_config["fill_color"],
        mean=input_config["mean"],
        std=input_config["std"],
        num_workers=args.workers,
        distributed=args.distributed,
        pin_mem=args.pin_mem,
        anchor_labeler=labeler,
        transform_fn=transform_train_fn,
        # collate_fn=collate_fn,
        axis_angle=args.axis_angle,
    )

    if args.val_skip > 1:
        dataset_eval = SkipSubset(dataset_eval, args.val_skip)
    loader_eval = create_loader(
        dataset_eval,
        input_size=input_config["input_size"],
        batch_size=args.batch_size,
        is_training=False,
        use_prefetcher=args.prefetcher,
        interpolation=input_config["interpolation"],
        fill_color=input_config["fill_color"],
        mean=input_config["mean"],
        std=input_config["std"],
        num_workers=args.workers,
        distributed=args.distributed,
        pin_mem=args.pin_mem,
        anchor_labeler=labeler,
        transform_fn=transform_eval_fn,
        # collate_fn=collate_fn,
        axis_angle=args.axis_angle,
    )

    evaluator = create_evaluator(
        args.dataset, loader_eval.dataset, distributed=args.distributed, pred_yxyx=False
    )

    return loader_train, loader_eval, evaluator


def train_epoch(
    epoch,
    model,
    loader,
    optimizer,
    args,
    lr_scheduler=None,
    saver=None,
    writer=None,
    output_dir="",
    amp_autocast=suppress,
    loss_scaler=None,
    model_ema=None,
):
    batch_time_m = utils.AverageMeter()
    data_time_m = utils.AverageMeter()
    losses_m = utils.AverageMeter()
    loss_box_m = utils.AverageMeter()
    loss_rot_m = utils.AverageMeter()
    loss_xy_m = utils.AverageMeter()
    loss_z_m = utils.AverageMeter()

    model.train()
    clip_params = get_clip_parameters(model, exclude_head="agc" in args.clip_mode)
    end = time.time()
    last_idx = len(loader) - 1
    num_updates = epoch * len(loader)
    for batch_idx, (input, target) in enumerate(loader):
        last_batch = batch_idx == last_idx
        data_time_m.update(time.time() - end)

        # image_grid = torchvision.utils.make_grid(input, nrow=4, normalize=True, scale_each=True)
        # cv2.imshow("train_grid", image_grid.cpu().numpy().transpose(1, 2, 0))
        # cv2.waitKey(1)

        if args.channels_last:
            input = input.contiguous(memory_format=torch.channels_last)

        with amp_autocast():
            output = model(input, target)
        loss = output["loss"]

        if not args.distributed:
            losses_m.update(loss.item(), input.size(0))
            loss_box_m.update(output["box_loss_weighted"].item(), input.size(0))
            loss_rot_m.update(output["rotation_loss_weighted"].item(), input.size(0))
            loss_xy_m.update(
                output["translation_xy_loss_weighted"].item(), input.size(0)
            )
            loss_z_m.update(output["translation_z_loss_weighted"].item(), input.size(0))

        optimizer.zero_grad()
        if loss_scaler is not None:
            loss_scaler(
                loss,
                optimizer,
                clip_grad=args.clip_grad,
                clip_mode=args.clip_mode,
                parameters=clip_params,
            )
        else:
            loss.backward()
            if args.clip_grad is not None:
                utils.dispatch_clip_grad(
                    clip_params, value=args.clip_grad, mode=args.clip_mode
                )
            optimizer.step()

        torch.cuda.synchronize()
        if model_ema is not None:
            model_ema.update(model)
        num_updates += 1

        batch_time_m.update(time.time() - end)
        if last_batch or batch_idx % args.log_interval == 0:
            lrl = [param_group["lr"] for param_group in optimizer.param_groups]
            lr = sum(lrl) / len(lrl)

            if args.distributed:
                reduced_loss = utils.reduce_tensor(loss.data, args.world_size)
                losses_m.update(reduced_loss.item(), input.size(0))

            if args.local_rank == 0:
                global_batch_size = input.size(0) * args.world_size
                logging.info(
                    f"Train: {epoch} [{batch_idx:>4d}/{len(loader)} ({100*batch_idx / last_idx:>3.0f}%)]  "
                    f"Loss: {losses_m.val:>9.6f} ({losses_m.avg:>6.4f})  "
                    f"Time: {batch_time_m.val:.3f}s, {global_batch_size / batch_time_m.val:>7.2f}/s  "
                    f"({batch_time_m.avg:.3f}s, {global_batch_size / batch_time_m.avg:>7.2f}/s)  "
                    f"LR: {lr:.3e}  "
                    f"Data: {data_time_m.val:.3f} ({data_time_m.avg:.3f})  "
                    f"L_Box_w: {loss_box_m.val:.3f} ({loss_box_m.avg:.3f})  "
                    f"L_Rot_w: {loss_rot_m.val:.3f} ({loss_rot_m.avg:.3f})  "
                    f"L_XY_w: {loss_xy_m.val:.3f} ({loss_xy_m.avg:.3f})  "
                    f"L_Z_w: {loss_z_m.val:.3f} ({loss_z_m.avg:.3f})"
                )

                if args.save_images and output_dir:
                    torchvision.utils.save_image(
                        input,
                        os.path.join(output_dir, "train-batch-%d.jpg" % batch_idx),
                        padding=0,
                        normalize=True,
                    )

        if writer:
            writer.add_scalar("loss/train/minibatches", losses_m.val, num_updates)
            writer.add_scalar("lr/train/minibatches", lr, num_updates)

        if (
            saver is not None
            and args.recovery_interval
            and (last_batch or (batch_idx + 1) % args.recovery_interval == 0)
        ):
            saver.save_recovery(epoch, batch_idx=batch_idx)

        if lr_scheduler is not None:
            lr_scheduler.step_update(num_updates=num_updates, metric=losses_m.avg)

        end = time.time()
        # end for

    if hasattr(optimizer, "sync_lookahead"):
        optimizer.sync_lookahead()

    return OrderedDict(
        [
            ("loss", losses_m.avg),
            ("loss_box", loss_box_m.avg),
            ("loss_rot", loss_rot_m.avg),
            ("loss_xy", loss_xy_m.avg),
            ("loss_z", loss_z_m.avg),
        ]
    )


def validate(model, loader, args, evaluator=None, log_suffix=""):
    batch_time_m = utils.AverageMeter()
    losses_m = utils.AverageMeter()
    loss_box_m = utils.AverageMeter()
    loss_rot_m = utils.AverageMeter()
    loss_xy_m = utils.AverageMeter()
    loss_z_m = utils.AverageMeter()

    model.eval()

    end = time.time()
    last_idx = len(loader) - 1
    with torch.no_grad():
        for batch_idx, (input, target) in enumerate(loader):
            last_batch = batch_idx == last_idx

            output = model(input, target)
            loss = output["loss"]

            if evaluator is not None:
                evaluator.add_predictions(output["detections"], target)

            if args.distributed:
                reduced_loss = utils.reduce_tensor(loss.data, args.world_size)
            else:
                reduced_loss = loss.data

            torch.cuda.synchronize()

            losses_m.update(reduced_loss.item(), input.size(0))
            loss_box_m.update(output["box_loss_weighted"].item(), input.size(0))
            loss_rot_m.update(output["rotation_loss_weighted"].item(), input.size(0))
            loss_xy_m.update(
                output["translation_xy_loss_weighted"].item(), input.size(0)
            )
            loss_z_m.update(output["translation_z_loss_weighted"].item(), input.size(0))

            batch_time_m.update(time.time() - end)
            end = time.time()
            if args.local_rank == 0 and (
                last_batch or batch_idx % args.log_interval == 0
            ):
                log_name = "Test" + log_suffix
                logging.info(
                    f"{log_name}: [{batch_idx:>4d}/{last_idx}]  "
                    f"Time: {batch_time_m.val:.3f} ({batch_time_m.avg:.3f})  "
                    f"Loss: {losses_m.val:>7.4f} ({losses_m.avg:>6.4f}) "
                    f"L_Box_w: {loss_box_m.val:>7.4f} ({loss_box_m.avg:>6.4f}) "
                    f"L_Rot_w: {loss_rot_m.val:>7.4f} ({loss_rot_m.avg:>6.4f}) "
                    f"L_XY_w: {loss_xy_m.val:>7.4f} ({loss_xy_m.avg:>6.4f}) "
                    f"L_Z_w: {loss_z_m.val:>7.4f} ({loss_z_m.avg:>6.4f})"
                )

    metrics = OrderedDict([("loss", losses_m.avg)])
    if evaluator is not None:
        metrics["map"] = evaluator.evaluate()

    return metrics


if __name__ == "__main__":
    args = _parse_args()
    train(args)