Use pre-commit to reformat code

Use pre-commit to reformat code

segmentation/configs/coco_stuff164k/README.md

@@ -6,11 +6,10 @@
 
 The Common Objects in COntext-stuff (COCO-stuff) dataset is a dataset for scene understanding tasks like semantic segmentation, object detection and image captioning. It is constructed by annotating the original COCO dataset, which originally annotated things while neglecting stuff annotations.  There are 164k images in COCO-Stuff-164K dataset that span over 172 categories including 80 things, 91 stuff, and 1 unlabeled class.
 
-
 ## Model Zoo
 
 ### Mask2Former + InternImage
 
 |   backbone    | resolution | mIoU (ss) | train speed | train time | #param | FLOPs |                              Config                               |                                                                                                                    Download                                                                                                                    |
-|:--------------:|:----------:|:-----------:|:-----------:|:----------:|:-------:|:-----:|:-----:|:-------------------:|
+| :-----------: | :--------: | :-------: | :---------: | :--------: | :----: | :---: | :---------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
 | InternImage-H |  896x896   |   52.6    | 1.6s / iter | 1.5d (2n)  | 1.31B  | 4635G | [config](./mask2former_internimage_h_896_80k_cocostuff164k_ss.py) | [ckpt](https://huggingface.co/OpenGVLab/InternImage/resolve/main/mask2former_internimage_h_896_80k_cocostuff164k.pth) \| [log](https://huggingface.co/OpenGVLab/InternImage/raw/main/mask2former_internimage_h_896_80k_cocostuff164k.log.json) |

segmentation/configs/mapillary/README.md

-
 # Mapillary Vistas
 
 Introduced by Neuhold et al. in [The Mapillary Vistas Dataset for Semantic Understanding of Street Scenes](http://openaccess.thecvf.com/content_ICCV_2017/papers/Neuhold_The_Mapillary_Vistas_ICCV_2017_paper.pdf)
@@ -7,20 +6,18 @@ Mapillary Vistas Dataset is a diverse street-level imagery dataset with pixel‑
 
 We first pretrain our models on the Mapillary Vistas dataset, then finetune them on the Cityscapes dataset.
 
-
 ## Model Zoo
 
 ### UperNet + InternImage
 
 |    backbone    | resolution | schd | train speed  | train time | #params | FLOPs |                            Config                            |                                                      Download                                                       |
-|:--------------:|:----------:|:------------:|:-----------:|:-----------:|:-------:|:-----:|:------:|:------------:|
+| :------------: | :--------: | :--: | :----------: | :--------: | :-----: | :---: | :----------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------: |
 | InternImage-L  |  512x1024  | 80k  | 0.50s / iter |   11.5h    |  256M   | 3234G | [config](./upernet_internimage_l_512x1024_80k_mapillary.py)  | [ckpt](https://huggingface.co/OpenGVLab/InternImage/resolve/main/upernet_internimage_l_512x1024_80k_mapillary.pth)  |
 | InternImage-XL |  512x1024  | 80k  | 0.56s / iter |    13h     |  368M   | 4022G | [config](./upernet_internimage_xl_512x1024_80k_mapillary.py) | [ckpt](https://huggingface.co/OpenGVLab/InternImage/resolve/main/upernet_internimage_xl_512x1024_80k_mapillary.pth) |
 
 ### SegFormerHead + InternImage
 
 |    backbone    | resolution | schd | train speed  | train time | #params | FLOPs |                             Config                             |                                                       Download                                                        |
-|:--------------:|:----------:|:------------:|:-----------:|:-----------:|:-------:|:-----:|:-----:|:---------:|
+| :------------: | :--------: | :--: | :----------: | :--------: | :-----: | :---: | :------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------: |
 | InternImage-L  |  512x1024  | 80k  | 0.37s / iter |     9h     |  220M   | 1580G | [config](./segformer_internimage_l_512x1024_80k_mapillary.py)  | [ckpt](https://huggingface.co/OpenGVLab/InternImage/resolve/main/segformer_internimage_l_512x1024_80k_mapillary.pth)  |
 | InternImage-XL |  512x1024  | 80k  | 0.43s / iter |    10h     |  330M   | 2364G | [config](./segformer_internimage_xl_512x1024_80k_mapillary.py) | [ckpt](https://huggingface.co/OpenGVLab/InternImage/resolve/main/segformer_internimage_xl_512x1024_80k_mapillary.pth) |
-

segmentation/deploy.py

@@ -6,9 +6,9 @@ import os.path as osp
 from functools import partial
 
 import mmcv
+import mmcv_custom
+import mmseg_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 mmseg_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 = []

segmentation/get_flops.py

 # Copyright (c) OpenMMLab. All rights reserved.
 import argparse
 
+import mmcv_custom  # noqa: F401,F403
+import mmseg_custom  # noqa: F401,F403
 import numpy as np
 import torch
 from mmcv import Config, DictAction
-
 from mmseg.models import build_segmentor
-import mmcv_custom   # noqa: F401,F403
-import mmseg_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')
 
@@ -44,9 +43,11 @@ def parse_args():
     args = parser.parse_args()
     return args
 
+
 def dcnv3_flops(n, k, c):
     return 5 * n * k * c
 
+
 def get_flops(model, input_shape):
     flops, params = get_model_complexity_info(model, input_shape, as_strings=False)
 

segmentation/image_demo.py

 # Copyright (c) OpenMMLab. All rights reserved.
+import os
+import os.path as osp
 from argparse import ArgumentParser
 
+import cv2
 import mmcv
-
 import mmcv_custom  # noqa: F401,F403
 import mmseg_custom  # noqa: F401,F403
-from mmseg.apis import inference_segmentor, init_segmentor, show_result_pyplot
-from mmseg.core.evaluation import get_palette
 from mmcv.runner import load_checkpoint
+from mmseg.apis import inference_segmentor, init_segmentor, show_result_pyplot
 from mmseg.core import get_classes
-import cv2
-import os.path as osp
-import os
+from mmseg.core.evaluation import get_palette
 
 
 def test_single_image(model, img_name, out_dir, color_palette, opacity):
     # check img_name is an image file or not
     assumed_imgformat = ('.png', '.jpg', '.jpeg', '.tiff', '.bmp', '.gif')
     if (not img_name.lower().endswith(assumed_imgformat)):
-        print(f"Skip {img_name} because it is not an image file.")
+        print(f'Skip {img_name} because it is not an image file.')
         return
 
     result = inference_segmentor(model, img_name)
@@ -34,7 +33,7 @@ def test_single_image(model, img_name, out_dir, color_palette, opacity):
     mmcv.mkdir_or_exist(out_dir)
     out_path = osp.join(out_dir, osp.basename(img_name))
     cv2.imwrite(out_path, img)
-    print(f"Result is save at {out_path}")
+    print(f'Result is save at {out_path}')
 
 
 def main():
@@ -43,7 +42,7 @@ def main():
         'img', help='Image file or a directory contains images')
     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(

segmentation/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',]

segmentation/mmcv_custom/custom_layer_decay_optimizer_constructor.py

@@ -10,13 +10,13 @@ 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 mmseg.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 var_name.startswith('decode_head.mask_embed'):
         return 0
@@ -28,12 +28,12 @@ def get_num_layer_for_swin(var_name, num_max_layer, depths):
         return 0
     elif var_name.startswith('decode_head.query_feat'):
         return 0
-    if var_name.startswith("backbone.cb_modules.0.patch_embed"):
+    if var_name.startswith('backbone.cb_modules.0.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])
@@ -86,64 +86,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) and "backbone" 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) and 'backbone' 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:

segmentation/mmseg_custom/__init__.py

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

segmentation/mmseg_custom/datasets/__init__.py

 # Copyright (c) OpenMMLab. All rights reserved.
+from .dataset_wrappers import ConcatDataset
 from .mapillary import MapillaryDataset  # noqa: F401,F403
 from .nyu_depth_v2 import NYUDepthV2Dataset  # noqa: F401,F403
 from .pipelines import *  # noqa: F401,F403
-from .dataset_wrappers import ConcatDataset
-
 
 __all__ = [
     'MapillaryDataset', 'NYUDepthV2Dataset', 'ConcatDataset'

segmentation/mmseg_custom/datasets/dataset_wrappers.py

@@ -5,9 +5,8 @@ from itertools import chain
 import mmcv
 import numpy as np
 from mmcv.utils import build_from_cfg, print_log
-from torch.utils.data.dataset import ConcatDataset as _ConcatDataset
-
 from mmseg.datasets.builder import DATASETS
+from torch.utils.data.dataset import ConcatDataset as _ConcatDataset
 
 
 @DATASETS.register_module(force=True)

segmentation/mmseg_custom/datasets/nyu_depth_v2.py

@@ -21,7 +21,6 @@ class NYUDepthV2Dataset(CustomDataset):
                'person', 'night stand', 'toilet', 'sink', 'lamp',
                'bathtub', 'bag', 'otherstructure', 'otherfurniture', 'otherprop')
 
-    
     PALETTE = [[120, 120, 120], [180, 120, 120], [6, 230, 230], [80, 50, 50],
                [4, 200, 3], [120, 120, 80], [140, 140, 140], [204, 5, 255],
                [230, 230, 230], [4, 250, 7], [224, 5, 255], [235, 255, 7],
@@ -40,4 +39,3 @@ class NYUDepthV2Dataset(CustomDataset):
             split=split,
             reduce_zero_label=True,
             **kwargs)
-        
\ No newline at end of file

segmentation/mmseg_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 mmseg.utils import get_root_logger
+from mmcv.runner import _load_checkpoint
 from mmseg.models.builder import BACKBONES
-import torch.nn.functional as F
-
+from mmseg.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,

segmentation/mmseg_custom/models/decode_heads/maskformer_head.py

@@ -388,8 +388,8 @@ class MaskFormerHead(BaseDecodeHead):
         # shape [num_gts, h, w] -> [num_gts * h * w]
         mask_targets = mask_targets.reshape(-1)
         # target is (1 - mask_targets) !!!
-        print("mask_pred:", mask_preds.shape)
-        print("mask_targets:", mask_targets.shape)
+        print('mask_pred:', mask_preds.shape)
+        print('mask_targets:', mask_targets.shape)
         loss_mask = self.loss_mask(
             mask_preds, 1 - mask_targets, avg_factor=num_total_masks * h * w)