content: # ------------------------------------------------------------------------
  # UP-DETR
  # Copyright (c) Tencent, Inc. and its affiliates. All Rights Reserved.
  # ------------------------------------------------------------------------
  # Modified from DETR (https://github.com/facebookresearch/detr)
  # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
  # ------------------------------------------------------------------------
  import argparse
  import datetime
  import json
  import random
  import time
  from pathlib import Path
  
  import numpy as np
  import torch
  from torch.utils.data import DataLoader, DistributedSampler
  
  import util.misc as utils
  from datasets import build_dataset
  from engine import train_one_epoch
  from models import build_model
  
  
  def get_args_parser():
      parser = argparse.ArgumentParser('Set transformer detector', add_help=False)
      parser.add_argument('--lr', default=1e-4, type=float)
      parser.add_argument('--batch_size', default=2, type=int)
      parser.add_argument('--weight_decay', default=1e-4, type=float)
      parser.add_argument('--epochs', default=60, type=int)
      parser.add_argument('--lr_drop', default=40, type=int)
      parser.add_argument('--clip_max_norm', default=0.1, type=float,
                          help='gradient clipping max norm')
  
      # * Backbone
      parser.add_argument('--backbone', default='resnet50', type=str,
                          help="Name of the convolutional backbone to use")
      parser.add_argument('--dilation', action='store_true',
                          help="If true, we replace stride with dilation in the last convolutional block (DC5)")
      parser.add_argument('--position_embedding', default='sine', type=str, choices=('sine', 'learned'),
                          help="Type of positional embedding to use on top of the image features")
  
      # * Transformer
      parser.add_argument('--enc_layers', default=6, type=int,
                          help="Number of encoding layers in the transformer")
      parser.add_argument('--dec_layers', default=6, type=int,
                          help="Number of decoding layers in the transformer")
      parser.add_argument('--dim_feedforward', default=2048, type=int,
                          help="Intermediate size of the feedforward layers in the transformer blocks")
      parser.add_argument('--hidden_dim', default=256, type=int,
                          help="Size of the embeddings (dimension of the transformer)")
      parser.add_argument('--dropout', default=0.1, type=float,
                          help="Dropout applied in the transformer")
      parser.add_argument('--nheads', default=8, type=int,
                          help="Number of attention heads inside the transformer's attentions")
      parser.add_argument('--num_queries', default=100, type=int,
                          help="Number of query slots")
      parser.add_argument('--num_patches', default=10, type=int, help='number of query patches')
      parser.add_argument('--pre_norm', action='store_true')
  
      # Loss
      parser.add_argument('--no_aux_loss', dest='aux_loss', action='store_false',
                          help="Disables auxiliary decoding losses (loss at each layer)")
      # * Matcher
      parser.add_argument('--set_cost_class', default=1, type=float,
                          help="Class coefficient in the matching cost")
      parser.add_argument('--set_cost_bbox', default=5, type=float,
                          help="L1 box coefficient in the matching cost")
      parser.add_argument('--set_cost_giou', default=2, type=float,
                          help="giou box coefficient in the matching cost")
      # * Loss coefficients
      parser.add_argument('--mask_loss_coef', default=1, type=float)
      parser.add_argument('--dice_loss_coef', default=1, type=float)
      parser.add_argument('--bbox_loss_coef', default=5, type=float)
      parser.add_argument('--giou_loss_coef', default=2, type=float)
      parser.add_argument('--eos_coef', default=0.1, type=float,
                          help="Relative classification weight of the no-object class")
  
      parser.add_argument('--output_dir', default='',
                          help='path where to save, empty for no saving')
      parser.add_argument('--device', default='cuda',
                          help='device to use for training / testing')
      parser.add_argument('--seed', default=42, type=int)
      parser.add_argument('--resume', default='', help='resume from checkpoint')
      parser.add_argument('--start_epoch', default=0, type=int, metavar='N',
                          help='start epoch')
      parser.add_argument('--eval', action='store_true')
      parser.add_argument('--num_workers', default=16, type=int)
  
      # distributed training parameters
      parser.add_argument('--world_size', default=1, type=int,
                          help='number of distributed processes')
      parser.add_argument('--dist_url', default='env://', help='url used to set up distributed training')
  
      # custom parameters
      parser.add_argument('--imagenet_path', type=str, default="", help="path to the ImageNet dataset, like ImageNet")
      parser.add_argument('--feature_recon', action='store_true', help='if set, add feature reconstruction branch')
      parser.add_argument('--query_shuffle', action='store_true', help='if set, shuffle object queries')
      parser.add_argument('--fre_cnn', action='store_true',
                          help="if set, freeze cnn parameters during the pre-training")
      return parser
  
  
  def main(args):
      utils.init_distributed_mode(args)
      print("git:\n  {}\n".format(utils.get_sha()))
  
      # align with DETR format
      args.dataset_file = 'ImageNet'
      args.masks = None
      # freeze cnn weights
      args.lr_backbone = 0 if args.fre_cnn else args.lr
      print(args)
  
      device = torch.device(args.device)
  
      # fix the seed for reproducibility
      seed = args.seed + utils.get_rank()
      torch.manual_seed(seed)
      np.random.seed(seed)
      random.seed(seed)
  
      model, criterion, postprocessors = build_model(args)
      model.to(device)
  
      model_without_ddp = model
      if args.distributed:
          model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
          model_without_ddp = model.module
      n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)
      print('number of params:', n_parameters)
  
      param_dicts = [
          {"params": [p for n, p in model_without_ddp.named_parameters() if "backbone" not in n and p.requires_grad]},
          {
              "params": [p for n, p in model_without_ddp.named_parameters() if "backbone" in n and p.requires_grad],
              "lr": args.lr_backbone,
          },
      ]
      optimizer = torch.optim.AdamW(param_dicts, lr=args.lr,
                                    weight_decay=args.weight_decay)
      lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, args.lr_drop)
  
      dataset_train = build_dataset(image_set='train', args=args)
  
      if args.distributed:
          sampler_train = DistributedSampler(dataset_train)
      else:
          sampler_train = torch.utils.data.RandomSampler(dataset_train)
  
      batch_sampler_train = torch.utils.data.BatchSampler(
          sampler_train, args.batch_size, drop_last=True)
  
      data_loader_train = DataLoader(dataset_train, batch_sampler=batch_sampler_train,
                                     collate_fn=utils.updetr_collate_fn, num_workers=args.num_workers)
  
      print(len(data_loader_train) * args.epochs)
  
      output_dir = Path(args.output_dir)
  
      if args.resume:
          checkpoint = torch.load(args.resume, map_location='cpu')
          model_without_ddp.load_state_dict(checkpoint['model'])
          if not args.eval and 'optimizer' in checkpoint and 'lr_scheduler' in checkpoint and 'epoch' in checkpoint:
              optimizer.load_state_dict(checkpoint['optimizer'])
              lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
              if lr_scheduler.step_size != args.lr_drop:
                  lr_scheduler.step_size = args.lr_drop
              args.start_epoch = checkpoint['epoch'] + 1
  
      print("Start training")
      start_time = time.time()
      for epoch in range(args.start_epoch, args.epochs):
          if args.distributed:
              sampler_train.set_epoch(epoch)
          train_stats = train_one_epoch(
              model, criterion, data_loader_train, optimizer, device, epoch,
              args.clip_max_norm)
          lr_scheduler.step()
          if args.output_dir:
              checkpoint_paths = [output_dir / 'checkpoint.pth']
              # extra checkpoint before LR drop and every 20 epochs
              if (epoch + 1) % args.lr_drop == 0 or (epoch + 1) % 20 == 0:
                  checkpoint_paths.append(output_dir / f'checkpoint{epoch:04}.pth')
              for checkpoint_path in checkpoint_paths:
                  utils.save_on_master({
                      'model': model_without_ddp.state_dict(),
                      'optimizer': optimizer.state_dict(),
                      'lr_scheduler': lr_scheduler.state_dict(),
                      'epoch': epoch,
                      'args': args,
                  }, checkpoint_path)
  
          log_stats = {**{f'train_{k}': v for k, v in train_stats.items()},
                       'epoch': epoch,
                       'n_parameters': n_parameters}
  
          if args.output_dir and utils.is_main_process():
              with (output_dir / "log.txt").open("a") as f:
                  f.write(json.dumps(log_stats) + "\n")
  
      total_time = time.time() - start_time
      total_time_str = str(datetime.timedelta(seconds=int(total_time)))
      print('Training time {}'.format(total_time_str))
  
  
  if __name__ == '__main__':
      parser = argparse.ArgumentParser('UP-DETR ptr-training script', parents=[get_args_parser()])
      args = parser.parse_args()
      if args.output_dir:
          Path(args.output_dir).mkdir(parents=True, exist_ok=True)
      main(args)
  