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/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')
 
@@ -103,8 +102,7 @@ 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

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(
@@ -52,8 +52,7 @@ 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__':

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:

detection/mmdet_custom/__init__.py

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

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()

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):
@@ -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/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
 
 

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)

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()

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']

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
 

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):