Use pre-commit to reformat code

Use pre-commit to reformat code

detection/deploy.py

@@ -6,9 +6,9 @@ import os.path as osp
 from functools import partial
 
 import mmcv
+import mmcv_custom
+import mmdet_custom
 import torch.multiprocessing as mp
-from torch.multiprocessing import Process, set_start_method
-
 from mmdeploy.apis import (create_calib_input_data, extract_model,
                            get_predefined_partition_cfg, torch2onnx,
                            torch2torchscript, visualize_model)
@@ -18,9 +18,8 @@ from mmdeploy.backend.sdk.export_info import export2SDK
 from mmdeploy.utils import (IR, Backend, get_backend, get_calib_filename,
                             get_ir_config, get_partition_config,
                             get_root_logger, load_config, target_wrapper)
+from torch.multiprocessing import Process, set_start_method
 
-import mmcv_custom
-import mmdet_custom
 
 def parse_args():
     parser = argparse.ArgumentParser(description='Export model to backends.')
@@ -242,9 +241,8 @@ def main():
 
     # ncnn quantization
     if backend == Backend.NCNN and quant:
-        from onnx2ncnn_quant_table import get_table
-
         from mmdeploy.apis.ncnn import get_quant_model_file, ncnn2int8
+        from onnx2ncnn_quant_table import get_table
         model_param_paths = backend_files[::2]
         model_bin_paths = backend_files[1::2]
         backend_files = []

detection/dist_train.sh

@@ -6,4 +6,4 @@ PORT=${PORT:-29500}
 
 PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
 python -m torch.distributed.launch --nproc_per_node=$GPUS --master_port=63667 \
-    $(dirname "$0")/train.py $CONFIG --launcher pytorch ${@:3}
\ No newline at end of file
+    $(dirname "$0")/train.py $CONFIG --launcher pytorch ${@:3}

detection/get_flops.py

 # Copyright (c) OpenMMLab. All rights reserved.
 import argparse
 
+import mmcv_custom  # noqa: F401,F403
+import mmdet_custom  # noqa: F401,F403
 import numpy as np
 import torch
 from mmcv import Config, DictAction
-
 from mmdet.models import build_detector
-import mmcv_custom  # noqa: F401,F403
-import mmdet_custom  # noqa: F401,F403
 
 try:
-    from mmcv.cnn.utils.flops_counter import flops_to_string, params_to_string
     from mmcv.cnn import get_model_complexity_info
+    from mmcv.cnn.utils.flops_counter import flops_to_string, params_to_string
 except ImportError:
     raise ImportError('Please upgrade mmcv to >0.6.2')
 
@@ -51,11 +50,11 @@ def dcnv3_flops(n, k, c):
 
 def get_flops(model, input_shape):
     flops, params = get_model_complexity_info(model, input_shape, as_strings=False)
-    
+
     backbone = model.backbone
     backbone_name = type(backbone).__name__
     _, H, W = input_shape
-    
+
     temp = 0
     if 'InternImage' in backbone_name:
         depths = backbone.depths  # [4, 4, 18, 4]
@@ -64,15 +63,15 @@ def get_flops(model, input_shape):
             h = H / (4 * (2 ** idx))
             w = W / (4 * (2 ** idx))
             temp += depth * dcnv3_flops(n=h * w, k=3 * 3, c=channels)
-    
+
     flops = flops + temp
     return flops_to_string(flops), params_to_string(params)
 
 
 if __name__ == '__main__':
-    
+
     args = parse_args()
-    
+
     if len(args.shape) == 1:
         h = w = args.shape[0]
     elif len(args.shape) == 2:
@@ -84,18 +83,18 @@ if __name__ == '__main__':
     if divisor > 0:
         h = int(np.ceil(h / divisor)) * divisor
         w = int(np.ceil(w / divisor)) * divisor
-    
+
     input_shape = (3, h, w)
-    
+
     cfg = Config.fromfile(args.config)
     if args.cfg_options is not None:
         cfg.merge_from_dict(args.cfg_options)
-    
+
     model = build_detector(
         cfg.model,
         train_cfg=cfg.get('train_cfg'),
         test_cfg=cfg.get('test_cfg'))
-    
+
     if torch.cuda.is_available():
         model.cuda()
     model.eval()
@@ -103,12 +102,11 @@ if __name__ == '__main__':
         model.forward = model.forward_dummy
     else:
         raise NotImplementedError(
-            'FLOPs counter is currently not currently supported with {}'.
-                format(model.__class__.__name__))
-    
+            'FLOPs counter is currently not currently supported with {}'.format(model.__class__.__name__))
+
     flops, params = get_flops(model, input_shape)
     split_line = '=' * 30
-    
+
     if divisor > 0 and \
             input_shape != orig_shape:
         print(f'{split_line}\nUse size divisor set input shape '

detection/image_demo.py

 # Copyright (c) OpenMMLab. All rights reserved.
 import asyncio
+import os.path as osp
 from argparse import ArgumentParser
 
-from mmdet.apis import (async_inference_detector, inference_detector,
-                        init_detector, show_result_pyplot)
 import mmcv
 import mmcv_custom  # noqa: F401,F403
 import mmdet_custom  # noqa: F401,F403
-import os.path as osp
+from mmdet.apis import (async_inference_detector, inference_detector,
+                        init_detector, show_result_pyplot)
 
 
 def parse_args():
@@ -15,7 +15,7 @@ def parse_args():
     parser.add_argument('img', help='Image file')
     parser.add_argument('config', help='Config file')
     parser.add_argument('checkpoint', help='Checkpoint file')
-    parser.add_argument('--out', type=str, default="demo", help='out dir')
+    parser.add_argument('--out', type=str, default='demo', help='out dir')
     parser.add_argument(
         '--device', default='cuda:0', help='Device used for inference')
     parser.add_argument(
@@ -38,7 +38,7 @@ def main(args):
     model = init_detector(args.config, args.checkpoint, device=args.device)
     # test a single image
     result = inference_detector(model, args.img)
-    
+
     mmcv.mkdir_or_exist(args.out)
     out_file = osp.join(args.out, osp.basename(args.img))
     # show the results
@@ -52,10 +52,9 @@ def main(args):
         mask_color=args.palette,
         out_file=out_file
     )
-    print(f"Result is save at {out_file}")
-
+    print(f'Result is save at {out_file}')
 
 
 if __name__ == '__main__':
     args = parse_args()
-    main(args)
\ No newline at end of file
+    main(args)

detection/mmcv_custom/__init__.py

@@ -5,6 +5,7 @@
 # --------------------------------------------------------
 
 # -*- coding: utf-8 -*-
-from .custom_layer_decay_optimizer_constructor import CustomLayerDecayOptimizerConstructor
+from .custom_layer_decay_optimizer_constructor import \
+    CustomLayerDecayOptimizerConstructor
 
 __all__ = ['CustomLayerDecayOptimizerConstructor']

detection/mmcv_custom/custom_layer_decay_optimizer_constructor.py

@@ -10,18 +10,18 @@ https://github.com/microsoft/unilm/blob/master/beit/semantic_segmentation/mmcv_c
 
 import json
 
-from mmcv.runner import OPTIMIZER_BUILDERS, DefaultOptimizerConstructor
-from mmcv.runner import get_dist_info
+from mmcv.runner import (OPTIMIZER_BUILDERS, DefaultOptimizerConstructor,
+                         get_dist_info)
 from mmdet.utils import get_root_logger
 
 
 def get_num_layer_for_swin(var_name, num_max_layer, depths):
-    if var_name.startswith("backbone.patch_embed"):
+    if var_name.startswith('backbone.patch_embed'):
         return 0
-    elif "level_embeds" in var_name:
+    elif 'level_embeds' in var_name:
         return 0
-    elif var_name.startswith("backbone.layers") or var_name.startswith(
-            "backbone.levels"):
+    elif var_name.startswith('backbone.layers') or var_name.startswith(
+            'backbone.levels'):
         if var_name.split('.')[3] not in ['downsample', 'norm']:
             stage_id = int(var_name.split('.')[2])
             layer_id = int(var_name.split('.')[4])
@@ -74,64 +74,64 @@ class CustomLayerDecayOptimizerConstructor(DefaultOptimizerConstructor):
         depths = self.paramwise_cfg.get('depths')
         offset_lr_scale = self.paramwise_cfg.get('offset_lr_scale', 1.0)
 
-        logger.info("Build CustomLayerDecayOptimizerConstructor %f - %d" %
+        logger.info('Build CustomLayerDecayOptimizerConstructor %f - %d' %
                     (layer_decay_rate, num_layers))
         weight_decay = self.base_wd
 
         for name, param in module.named_parameters():
             if not param.requires_grad:
                 continue  # frozen weights
-            if len(param.shape) == 1 or name.endswith(".bias") or \
-                    "relative_position" in name or \
-                    "norm" in name or\
-                    "sampling_offsets" in name:
-                group_name = "no_decay"
+            if len(param.shape) == 1 or name.endswith('.bias') or \
+                    'relative_position' in name or \
+                    'norm' in name or\
+                    'sampling_offsets' in name:
+                group_name = 'no_decay'
                 this_weight_decay = 0.
             else:
-                group_name = "decay"
+                group_name = 'decay'
                 this_weight_decay = weight_decay
 
             layer_id = get_num_layer_for_swin(name, num_layers, depths)
             if layer_id == num_layers - 1 and dino_head and \
-                    ("sampling_offsets" in name or "reference_points" in name):
-                group_name = "layer_%d_%s_0.1x" % (layer_id, group_name)
-            elif "sampling_offsets" in name or "reference_points" in name:
-                group_name = "layer_%d_%s_offset_lr_scale" % (layer_id,
+                    ('sampling_offsets' in name or 'reference_points' in name):
+                group_name = 'layer_%d_%s_0.1x' % (layer_id, group_name)
+            elif 'sampling_offsets' in name or 'reference_points' in name:
+                group_name = 'layer_%d_%s_offset_lr_scale' % (layer_id,
                                                               group_name)
             else:
-                group_name = "layer_%d_%s" % (layer_id, group_name)
+                group_name = 'layer_%d_%s' % (layer_id, group_name)
 
             if group_name not in parameter_groups:
                 scale = layer_decay_rate ** (num_layers - layer_id - 1)
                 if scale < 1 and backbone_small_lr == True:
                     scale = scale * 0.1
-                if "0.1x" in group_name:
+                if '0.1x' in group_name:
                     scale = scale * 0.1
-                if "offset_lr_scale" in group_name:
+                if 'offset_lr_scale' in group_name:
                     scale = scale * offset_lr_scale
 
                 parameter_groups[group_name] = {
-                    "weight_decay": this_weight_decay,
-                    "params": [],
-                    "param_names": [],
-                    "lr_scale": scale,
-                    "group_name": group_name,
-                    "lr": scale * self.base_lr,
+                    'weight_decay': this_weight_decay,
+                    'params': [],
+                    'param_names': [],
+                    'lr_scale': scale,
+                    'group_name': group_name,
+                    'lr': scale * self.base_lr,
                 }
 
-            parameter_groups[group_name]["params"].append(param)
-            parameter_groups[group_name]["param_names"].append(name)
+            parameter_groups[group_name]['params'].append(param)
+            parameter_groups[group_name]['param_names'].append(name)
         rank, _ = get_dist_info()
         if rank == 0:
             to_display = {}
             for key in parameter_groups:
                 to_display[key] = {
-                    "param_names": parameter_groups[key]["param_names"],
-                    "lr_scale": parameter_groups[key]["lr_scale"],
-                    "lr": parameter_groups[key]["lr"],
-                    "weight_decay": parameter_groups[key]["weight_decay"],
+                    'param_names': parameter_groups[key]['param_names'],
+                    'lr_scale': parameter_groups[key]['lr_scale'],
+                    'lr': parameter_groups[key]['lr'],
+                    'weight_decay': parameter_groups[key]['weight_decay'],
                 }
-            logger.info("Param groups = %s" % json.dumps(to_display, indent=2))
+            logger.info('Param groups = %s' % json.dumps(to_display, indent=2))
 
         # state_dict = module.state_dict()
         # for group_name in parameter_groups:
@@ -139,4 +139,4 @@ class CustomLayerDecayOptimizerConstructor(DefaultOptimizerConstructor):
         #     for name in group["param_names"]:
         #         group["params"].append(state_dict[name])
 
-        params.extend(parameter_groups.values())
\ No newline at end of file
+        params.extend(parameter_groups.values())

detection/mmdet_custom/__init__.py

@@ -4,5 +4,5 @@
 # Licensed under The MIT License [see LICENSE for details]
 # --------------------------------------------------------
 
+from .datasets import *
 from .models import *  # noqa: F401,F403
-from .datasets import *
\ No newline at end of file

detection/mmdet_custom/datasets/__init__.py

@@ -4,4 +4,4 @@
 # Licensed under The MIT License [see LICENSE for details]
 # --------------------------------------------------------
 
-from .crowd_human import CrowdHumanDataset
\ No newline at end of file
+from .crowd_human import CrowdHumanDataset

detection/mmdet_custom/datasets/crowd_human.py

@@ -8,13 +8,11 @@ from collections import OrderedDict
 import mmcv
 import numpy as np
 from mmcv.utils import print_log
-from terminaltables import AsciiTable
-
 from mmdet.core import eval_recalls
 from mmdet.datasets.api_wrappers import COCO, COCOeval
-
-from mmdet.datasets.custom import CustomDataset
 from mmdet.datasets.builder import DATASETS
+from mmdet.datasets.custom import CustomDataset
+from terminaltables import AsciiTable
 
 
 @DATASETS.register_module()
@@ -526,4 +524,4 @@ class CrowdHumanDataset(CustomDataset):
                     f'{ap[4]:.3f} {ap[5]:.3f}')
         if tmp_dir is not None:
             tmp_dir.cleanup()
-        return
\ No newline at end of file
+        return

detection/mmdet_custom/models/__init__.py

@@ -7,4 +7,4 @@
 from .backbones import *  # noqa: F401,F403
 from .dense_heads import *  # noqa: F401,F403
 from .detectors import *  # noqa: F401,F403
-from .utils import *  # noqa: F401,F403
\ No newline at end of file
+from .utils import *  # noqa: F401,F403

detection/mmdet_custom/models/backbones/intern_image.py

@@ -4,18 +4,18 @@
 # Licensed under The MIT License [see LICENSE for details]
 # --------------------------------------------------------
 
+from collections import OrderedDict
+
 import torch
 import torch.nn as nn
-from collections import OrderedDict
+import torch.nn.functional as F
 import torch.utils.checkpoint as checkpoint
-from timm.models.layers import trunc_normal_, DropPath
-from mmcv.runner import _load_checkpoint
 from mmcv.cnn import constant_init, trunc_normal_init
-from mmdet.utils import get_root_logger
+from mmcv.runner import _load_checkpoint
 from mmdet.models.builder import BACKBONES
-import torch.nn.functional as F
-
+from mmdet.utils import get_root_logger
 from ops_dcnv3 import modules as dcnv3
+from timm.models.layers import DropPath, trunc_normal_
 
 
 class to_channels_first(nn.Module):
@@ -86,7 +86,7 @@ class CrossAttention(nn.Module):
         attn_head_dim (int, optional): Dimension of attention head.
         out_dim (int, optional): Dimension of output.
     """
-    
+
     def __init__(self,
                  dim,
                  num_heads=8,
@@ -178,7 +178,7 @@ class AttentiveBlock(nn.Module):
         attn_head_dim (int, optional): Dimension of attention head. Default: None.
         out_dim (int, optional): Dimension of output. Default: None.
     """
-    
+
     def __init__(self,
                  dim,
                  num_heads,
@@ -187,7 +187,7 @@ class AttentiveBlock(nn.Module):
                  drop=0.,
                  attn_drop=0.,
                  drop_path=0.,
-                 norm_layer="LN",
+                 norm_layer='LN',
                  attn_head_dim=None,
                  out_dim=None):
         super().__init__()
@@ -593,10 +593,10 @@ class InternImage(nn.Module):
         logger.info(f'using activation layer: {act_layer}')
         logger.info(f'using main norm layer: {norm_layer}')
         logger.info(f'using dpr: {drop_path_type}, {drop_path_rate}')
-        logger.info(f"level2_post_norm: {level2_post_norm}")
-        logger.info(f"level2_post_norm_block_ids: {level2_post_norm_block_ids}")
-        logger.info(f"res_post_norm: {res_post_norm}")
-        logger.info(f"use_dcn_v4_op: {use_dcn_v4_op}")
+        logger.info(f'level2_post_norm: {level2_post_norm}')
+        logger.info(f'level2_post_norm_block_ids: {level2_post_norm_block_ids}')
+        logger.info(f'res_post_norm: {res_post_norm}')
+        logger.info(f'use_dcn_v4_op: {use_dcn_v4_op}')
 
         in_chans = 3
         self.patch_embed = StemLayer(in_chans=in_chans,

detection/mmdet_custom/models/dense_heads/__init__.py

@@ -8,4 +8,4 @@ from .deformable_detr_head import DeformableDETRHead
 from .detr_head import DETRHead
 from .dino_head import DINOHead
 
-__all__ = ['DeformableDETRHead', 'DETRHead', 'DINOHead']
\ No newline at end of file
+__all__ = ['DeformableDETRHead', 'DETRHead', 'DINOHead']

detection/mmdet_custom/models/dense_heads/deformable_detr_head.py

@@ -6,10 +6,10 @@ import torch.nn as nn
 import torch.nn.functional as F
 from mmcv.cnn import Linear, bias_init_with_prob, constant_init
 from mmcv.runner import force_fp32
-
 from mmdet.core import multi_apply
-from mmdet.models.utils.transformer import inverse_sigmoid
 from mmdet.models.builder import HEADS
+from mmdet.models.utils.transformer import inverse_sigmoid
+
 from .detr_head import DETRHead
 
 
@@ -51,7 +51,7 @@ class DeformableDETRHead(DETRHead):
 
     def _init_layers(self):
         """Initialize classification branch and regression branch of head."""
-        
+
         if not self.use_2fc_cls_branch:
             fc_cls = Linear(self.embed_dims, self.cls_out_channels)
         else:

detection/mmdet_custom/models/dense_heads/detr_head.py

 # Copyright (c) OpenMMLab. All rights reserved.
+import numpy as np
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 from mmcv.cnn import Conv2d, Linear, build_activation_layer
 from mmcv.cnn.bricks.transformer import FFN, build_positional_encoding
 from mmcv.runner import force_fp32
-
 from mmdet.core import (bbox_cxcywh_to_xyxy, bbox_xyxy_to_cxcywh,
                         build_assigner, build_sampler, multi_apply,
                         reduce_mean)
-from mmdet.models.utils import build_transformer
 from mmdet.models.builder import HEADS, build_loss
 from mmdet.models.dense_heads.anchor_free_head import AnchorFreeHead
-import numpy as np
+from mmdet.models.utils import build_transformer
 
 
 @HEADS.register_module(force=True)
@@ -91,11 +90,11 @@ class DETRHead(AnchorFreeHead):
             # assert isinstance(class_weight, float), 'Expected ' \
             #     'class_weight to have type float. Found ' \
             #     f'{type(class_weight)}.'
-           
+
             # NOTE following the official DETR rep0, bg_cls_weight means
             # relative classification weight of the no-object class.
             bg_cls_weight = loss_cls.get('bg_cls_weight', class_weight)
-            
+
             assert isinstance(bg_cls_weight, float), 'Expected ' \
                 'bg_cls_weight to have type float. Found ' \
                 f'{type(bg_cls_weight)}.'
@@ -130,7 +129,7 @@ class DETRHead(AnchorFreeHead):
             # DETR sampling=False, so use PseudoSampler
             sampler_cfg = dict(type='PseudoSampler')
             self.sampler = build_sampler(sampler_cfg, context=self)
-            
+
         self.num_query = num_query
         self.num_classes = num_classes
         self.in_channels = in_channels
@@ -369,7 +368,7 @@ class DETRHead(AnchorFreeHead):
         else:
             fed_loss_classes = unique_gt_classes
         return fed_loss_classes
-    
+
     def loss_single(self,
                     cls_scores,
                     bbox_preds,

detection/mmdet_custom/models/dense_heads/dino_head.py

@@ -2,14 +2,14 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-
+from mmcv.runner import force_fp32
 from mmdet.core import (bbox_cxcywh_to_xyxy, bbox_xyxy_to_cxcywh, multi_apply,
                         reduce_mean)
-from ..utils import build_dn_generator
-from mmdet.models.utils.transformer import inverse_sigmoid
 from mmdet.models.builder import HEADS
+from mmdet.models.utils.transformer import inverse_sigmoid
+
+from ..utils import build_dn_generator
 from .deformable_detr_head import DeformableDETRHead
-from mmcv.runner import force_fp32
 
 
 @HEADS.register_module()
@@ -105,7 +105,7 @@ class DINOHead(DeformableDETRHead):
             # label_embedding won't be used in producing loss, which raises
             # RuntimeError when using distributed mode.
             hs[0] += self.label_embedding.weight[0, 0] * 0.0
-            
+
         outputs_classes = []
         outputs_coords = []
 
@@ -198,7 +198,7 @@ class DINOHead(DeformableDETRHead):
             dn_losses_cls, dn_losses_bbox, dn_losses_iou = self.loss_dn(
                 dn_cls_scores, dn_bbox_preds, gt_bboxes_list, gt_labels_list,
                 img_metas, dn_meta)
-    
+
             # collate denoising loss
             loss_dict['dn_loss_cls'] = dn_losses_cls[-1]
             loss_dict['dn_loss_bbox'] = dn_losses_bbox[-1]
@@ -211,7 +211,7 @@ class DINOHead(DeformableDETRHead):
                 loss_dict[f'd{num_dec_layer}.dn_loss_bbox'] = loss_bbox_i
                 loss_dict[f'd{num_dec_layer}.dn_loss_iou'] = loss_iou_i
                 num_dec_layer += 1
-                
+
             return loss_dict
 
     def loss_dn(self, dn_cls_scores, dn_bbox_preds, gt_bboxes_list,
@@ -257,7 +257,7 @@ class DINOHead(DeformableDETRHead):
                 1,
                 dtype=cls_scores.dtype,
                 device=cls_scores.device)
-            
+
         # Compute the average number of gt boxes across all gpus, for
         # normalization purposes
         num_total_pos = loss_cls.new_tensor([num_total_pos])

detection/mmdet_custom/models/detectors/__init__.py

@@ -6,4 +6,4 @@
 
 from .dino import DINO
 
-__all__ = ['DINO']
\ No newline at end of file
+__all__ = ['DINO']

detection/mmdet_custom/models/detectors/dino.py

@@ -5,6 +5,6 @@ from mmdet.models.detectors.detr import DETR
 
 @DETECTORS.register_module()
 class DINO(DETR):
-    
+
     def __init__(self, *args, **kwargs):
-        super(DETR, self).__init__(*args, **kwargs)
\ No newline at end of file
+        super(DETR, self).__init__(*args, **kwargs)

detection/mmdet_custom/models/utils/__init__.py

 from .query_denoising import build_dn_generator
-from .transformer import (DinoTransformer, DinoTransformerDecoder)
+from .transformer import DinoTransformer, DinoTransformerDecoder
 
-
-__all__ = ['build_dn_generator', 'DinoTransformer', 'DinoTransformerDecoder']
\ No newline at end of file
+__all__ = ['build_dn_generator', 'DinoTransformer', 'DinoTransformerDecoder']

detection/mmdet_custom/models/utils/query_denoising.py

 # Copyright (c) OpenMMLab. All rights reserved.
 import torch
 from mmcv.runner import BaseModule
-
 from mmdet.core import bbox_xyxy_to_cxcywh
 from mmdet.models.utils.transformer import inverse_sigmoid
 
@@ -160,7 +159,7 @@ class DnQueryGenerator(BaseModule):
             m = known_labels_expand.long().to('cuda')
             input_label_embed = label_enc(m)
             input_bbox_embed = inverse_sigmoid(known_bbox_expand, eps=1e-3)
-            
+
             padding_label = torch.zeros(pad_size, self.hidden_dim).cuda()
             padding_bbox = torch.zeros(pad_size, 4).cuda()
 
@@ -231,4 +230,4 @@ def build_dn_generator(dn_args):
     elif type == 'CdnQueryGenerator':
         return CdnQueryGenerator(**dn_args)
     else:
-        raise NotImplementedError(f'{type} is not supported yet')
\ No newline at end of file
+        raise NotImplementedError(f'{type} is not supported yet')

detection/mmdet_custom/models/utils/transformer.py

 import math
+
 import torch
 import torch.nn as nn
+from mmcv.cnn.bricks.registry import (DROPOUT_LAYERS, FEEDFORWARD_NETWORK,
+                                      TRANSFORMER_LAYER_SEQUENCE)
 from mmdet.models.utils.builder import TRANSFORMER
-from mmcv.cnn.bricks.registry import (
-    TRANSFORMER_LAYER_SEQUENCE, FEEDFORWARD_NETWORK, DROPOUT_LAYERS)
-from mmdet.models.utils.transformer import (inverse_sigmoid,
+from mmdet.models.utils.transformer import (DeformableDetrTransformer,
                                             DeformableDetrTransformerDecoder,
-                                            DeformableDetrTransformer)
+                                            inverse_sigmoid)
 
 
 def build_MLP(input_dim, hidden_dim, output_dim, num_layers):
@@ -97,7 +98,7 @@ class DinoTransformerDecoder(DeformableDetrTransformerDecoder):
                 assert reference_points.shape[-1] == 2
                 reference_points_input = \
                     reference_points[:, :, None] * valid_ratios[:, None]
-            
+
             if self.with_rp_noise and self.training:
                 device = reference_points.device
                 b, n, d = reference_points.size()