Merge branch 'add_Recommendation' into 'main'

添加openmmlab测试用例

See merge request dcutoolkit/deeplearing/dlexamples_new!32

openmmlab_test/mmclassification-speed-benchmark/tools/publish_model.py

+import argparse
+import subprocess
+
+import torch
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Process a checkpoint to be published')
+    parser.add_argument('in_file', help='input checkpoint filename')
+    parser.add_argument('out_file', help='output checkpoint filename')
+    args = parser.parse_args()
+    return args
+
+
+def process_checkpoint(in_file, out_file):
+    checkpoint = torch.load(in_file, map_location='cpu')
+    # remove optimizer for smaller file size
+    if 'optimizer' in checkpoint:
+        del checkpoint['optimizer']
+    # if it is necessary to remove some sensitive data in checkpoint['meta'],
+    # add the code here.
+    torch.save(checkpoint, out_file)
+    sha = subprocess.check_output(['sha256sum', out_file]).decode()
+    if out_file.endswith('.pth'):
+        out_file_name = out_file[:-4]
+    else:
+        out_file_name = out_file
+    final_file = out_file_name + f'-{sha[:8]}.pth'
+    subprocess.Popen(['mv', out_file, final_file])
+
+
+def main():
+    args = parse_args()
+    process_checkpoint(args.in_file, args.out_file)
+
+
+if __name__ == '__main__':
+    main()

openmmlab_test/mmclassification-speed-benchmark/tools/slurm_test.sh

+#!/usr/bin/env bash
+
+set -x
+
+PARTITION=$1
+JOB_NAME=$2
+CONFIG=$3
+CHECKPOINT=$4
+GPUS=${GPUS:-8}
+GPUS_PER_NODE=${GPUS_PER_NODE:-8}
+CPUS_PER_TASK=${CPUS_PER_TASK:-5}
+PY_ARGS=${@:5}
+SRUN_ARGS=${SRUN_ARGS:-""}
+
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
+srun -p ${PARTITION} \
+    --job-name=${JOB_NAME} \
+    --gres=gpu:${GPUS_PER_NODE} \
+    --ntasks=${GPUS} \
+    --ntasks-per-node=${GPUS_PER_NODE} \
+    --cpus-per-task=${CPUS_PER_TASK} \
+    --kill-on-bad-exit=1 \
+    ${SRUN_ARGS} \
+    python -u tools/test.py ${CONFIG} ${CHECKPOINT} --launcher="slurm" ${PY_ARGS}

openmmlab_test/mmclassification-speed-benchmark/tools/slurm_train.sh

+#!/usr/bin/env bash
+
+set -x
+
+PARTITION=$1
+JOB_NAME=$2
+CONFIG=$3
+WORK_DIR=$4
+GPUS=${GPUS:-8}
+GPUS_PER_NODE=${GPUS_PER_NODE:-8}
+CPUS_PER_TASK=${CPUS_PER_TASK:-5}
+SRUN_ARGS=${SRUN_ARGS:-""}
+PY_ARGS=${@:5}
+
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH \
+srun -p ${PARTITION} \
+    --job-name=${JOB_NAME} \
+    --gres=gpu:${GPUS_PER_NODE} \
+    --ntasks=${GPUS} \
+    --ntasks-per-node=${GPUS_PER_NODE} \
+    --cpus-per-task=${CPUS_PER_TASK} \
+    --kill-on-bad-exit=1 \
+    ${SRUN_ARGS} \
+    python -u tools/train.py ${CONFIG} --work-dir=${WORK_DIR} --launcher="slurm" ${PY_ARGS}

openmmlab_test/mmclassification-speed-benchmark/tools/test.py

+import argparse
+import os
+import warnings
+
+import mmcv
+import numpy as np
+import torch
+from mmcv import DictAction
+from mmcv.parallel import MMDataParallel, MMDistributedDataParallel
+from mmcv.runner import get_dist_info, init_dist, load_checkpoint
+
+from mmcls.apis import multi_gpu_test, single_gpu_test
+from mmcls.datasets import build_dataloader, build_dataset
+from mmcls.models import build_classifier
+
+# TODO import `wrap_fp16_model` from mmcv and delete them from mmcls
+try:
+    from mmcv.runner import wrap_fp16_model
+except ImportError:
+    warnings.warn('wrap_fp16_model from mmcls will be deprecated.'
+                  'Please install mmcv>=1.1.4.')
+    from mmcls.core import wrap_fp16_model
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='mmcls test model')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('checkpoint', help='checkpoint file')
+    parser.add_argument('--out', help='output result file')
+    parser.add_argument(
+        '--metrics',
+        type=str,
+        nargs='+',
+        help='evaluation metrics, which depends on the dataset, e.g., '
+        '"accuracy", "precision", "recall", "f1_score", "support" for single '
+        'label dataset, and "mAP", "CP", "CR", "CF1", "OP", "OR", "OF1" for '
+        'multi-label dataset')
+    parser.add_argument('--show', action='store_true', help='show results')
+    parser.add_argument(
+        '--show-dir', help='directory where painted images will be saved')
+    parser.add_argument(
+        '--gpu_collect',
+        action='store_true',
+        help='whether to use gpu to collect results')
+    parser.add_argument('--tmpdir', help='tmp dir for writing some results')
+    parser.add_argument(
+        '--options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file.')
+    parser.add_argument(
+        '--metric-options',
+        nargs='+',
+        action=DictAction,
+        default={},
+        help='custom options for evaluation, the key-value pair in xxx=yyy '
+        'format will be parsed as a dict metric_options for dataset.evaluate()'
+        ' function.')
+    parser.add_argument(
+        '--show-options',
+        nargs='+',
+        action=DictAction,
+        help='custom options for show_result. key-value pair in xxx=yyy.'
+        'Check available options in `model.show_result`.')
+    parser.add_argument(
+        '--launcher',
+        choices=['none', 'pytorch', 'slurm', 'mpi'],
+        default='none',
+        help='job launcher')
+    parser.add_argument('--local_rank', type=int, default=0)
+    parser.add_argument(
+        '--device',
+        choices=['cpu', 'cuda'],
+        default='cuda',
+        help='device used for testing')
+    args = parser.parse_args()
+    if 'LOCAL_RANK' not in os.environ:
+        os.environ['LOCAL_RANK'] = str(args.local_rank)
+    return args
+
+
+def main():
+    args = parse_args()
+
+    cfg = mmcv.Config.fromfile(args.config)
+    if args.options is not None:
+        cfg.merge_from_dict(args.options)
+    # set cudnn_benchmark
+    if cfg.get('cudnn_benchmark', False):
+        torch.backends.cudnn.benchmark = True
+    cfg.model.pretrained = None
+    cfg.data.test.test_mode = True
+
+    # init distributed env first, since logger depends on the dist info.
+    if args.launcher == 'none':
+        distributed = False
+    else:
+        distributed = True
+        init_dist(args.launcher, **cfg.dist_params)
+
+    # build the dataloader
+    dataset = build_dataset(cfg.data.test)
+    # the extra round_up data will be removed during gpu/cpu collect
+    data_loader = build_dataloader(
+        dataset,
+        samples_per_gpu=cfg.data.samples_per_gpu,
+        workers_per_gpu=cfg.data.workers_per_gpu,
+        dist=distributed,
+        shuffle=False,
+        round_up=True)
+
+    # build the model and load checkpoint
+    model = build_classifier(cfg.model)
+    fp16_cfg = cfg.get('fp16', None)
+    if fp16_cfg is not None:
+        wrap_fp16_model(model)
+    checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
+
+    if 'CLASSES' in checkpoint.get('meta', {}):
+        CLASSES = checkpoint['meta']['CLASSES']
+    else:
+        from mmcls.datasets import ImageNet
+        warnings.simplefilter('once')
+        warnings.warn('Class names are not saved in the checkpoint\'s '
+                      'meta data, use imagenet by default.')
+        CLASSES = ImageNet.CLASSES
+
+    if not distributed:
+        if args.device == 'cpu':
+            model = model.cpu()
+        else:
+            model = MMDataParallel(model, device_ids=[0])
+        model.CLASSES = CLASSES
+        show_kwargs = {} if args.show_options is None else args.show_options
+        outputs = single_gpu_test(model, data_loader, args.show, args.show_dir,
+                                  **show_kwargs)
+    else:
+        model = MMDistributedDataParallel(
+            model.cuda(),
+            device_ids=[torch.cuda.current_device()],
+            broadcast_buffers=False)
+        outputs = multi_gpu_test(model, data_loader, args.tmpdir,
+                                 args.gpu_collect)
+
+    rank, _ = get_dist_info()
+    if rank == 0:
+        if args.metrics:
+            results = dataset.evaluate(outputs, args.metrics,
+                                       args.metric_options)
+            for k, v in results.items():
+                print(f'\n{k} : {v:.2f}')
+        else:
+            warnings.warn('Evaluation metrics are not specified.')
+            scores = np.vstack(outputs)
+            pred_score = np.max(scores, axis=1)
+            pred_label = np.argmax(scores, axis=1)
+            pred_class = [CLASSES[lb] for lb in pred_label]
+            results = {
+                'pred_score': pred_score,
+                'pred_label': pred_label,
+                'pred_class': pred_class
+            }
+            if not args.out:
+                print('\nthe predicted result for the first element is '
+                      f'pred_score = {pred_score[0]:.2f}, '
+                      f'pred_label = {pred_label[0]} '
+                      f'and pred_class = {pred_class[0]}. '
+                      'Specify --out to save all results to files.')
+    if args.out and rank == 0:
+        print(f'\nwriting results to {args.out}')
+        mmcv.dump(results, args.out)
+
+
+if __name__ == '__main__':
+    main()

openmmlab_test/mmclassification-speed-benchmark/tools/train.py

+import argparse
+import copy
+import os
+import os.path as osp
+import time
+
+import mmcv
+import torch
+from mmcv import Config, DictAction
+from mmcv.runner import get_dist_info, init_dist
+
+from mmcls import __version__
+from mmcls.apis import set_random_seed, train_model
+from mmcls.datasets import build_dataset
+from mmcls.models import build_classifier
+from mmcls.utils import collect_env, get_root_logger
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Train a model')
+    parser.add_argument('config', help='train config file path')
+    parser.add_argument('--work-dir', help='the dir to save logs and models')
+    parser.add_argument(
+        '--resume-from', help='the checkpoint file to resume from')
+    parser.add_argument(
+        '--no-validate',
+        action='store_true',
+        help='whether not to evaluate the checkpoint during training')
+    group_gpus = parser.add_mutually_exclusive_group()
+    group_gpus.add_argument('--device', help='device used for training')
+    group_gpus.add_argument(
+        '--gpus',
+        type=int,
+        help='number of gpus to use '
+        '(only applicable to non-distributed training)')
+    group_gpus.add_argument(
+        '--gpu-ids',
+        type=int,
+        nargs='+',
+        help='ids of gpus to use '
+        '(only applicable to non-distributed training)')
+    parser.add_argument('--seed', type=int, default=None, help='random seed')
+    parser.add_argument(
+        '--deterministic',
+        action='store_true',
+        help='whether to set deterministic options for CUDNN backend.')
+    parser.add_argument(
+        '--options', nargs='+', action=DictAction, help='arguments in dict')
+    parser.add_argument(
+        '--launcher',
+        choices=['none', 'pytorch', 'slurm', 'mpi'],
+        default='none',
+        help='job launcher')
+    parser.add_argument('--local_rank', type=int, default=0)
+    args = parser.parse_args()
+    if 'LOCAL_RANK' not in os.environ:
+        os.environ['LOCAL_RANK'] = str(args.local_rank)
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    cfg = Config.fromfile(args.config)
+    if args.options is not None:
+        cfg.merge_from_dict(args.options)
+    # set cudnn_benchmark
+    if cfg.get('cudnn_benchmark', False):
+        torch.backends.cudnn.benchmark = True
+
+    # work_dir is determined in this priority: CLI > segment in file > filename
+    if args.work_dir is not None:
+        # update configs according to CLI args if args.work_dir is not None
+        cfg.work_dir = args.work_dir
+    elif cfg.get('work_dir', None) is None:
+        # use config filename as default work_dir if cfg.work_dir is None
+        cfg.work_dir = osp.join('./work_dirs',
+                                osp.splitext(osp.basename(args.config))[0])
+    if args.resume_from is not None:
+        cfg.resume_from = args.resume_from
+    if args.gpu_ids is not None:
+        cfg.gpu_ids = args.gpu_ids
+    else:
+        cfg.gpu_ids = range(1) if args.gpus is None else range(args.gpus)
+
+    # init distributed env first, since logger depends on the dist info.
+    if args.launcher == 'none':
+        distributed = False
+    else:
+        distributed = True
+        init_dist(args.launcher, **cfg.dist_params)
+        _, world_size = get_dist_info()
+        cfg.gpu_ids = range(world_size)
+
+    # create work_dir
+    mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
+    # dump config
+    cfg.dump(osp.join(cfg.work_dir, osp.basename(args.config)))
+    # init the logger before other steps
+    timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
+    log_file = osp.join(cfg.work_dir, f'{timestamp}.log')
+    logger = get_root_logger(log_file=log_file, log_level=cfg.log_level)
+
+    # init the meta dict to record some important information such as
+    # environment info and seed, which will be logged
+    meta = dict()
+    # log env info
+    env_info_dict = collect_env()
+    env_info = '\n'.join([(f'{k}: {v}') for k, v in env_info_dict.items()])
+    dash_line = '-' * 60 + '\n'
+    logger.info('Environment info:\n' + dash_line + env_info + '\n' +
+                dash_line)
+    meta['env_info'] = env_info
+
+    # log some basic info
+    logger.info(f'Distributed training: {distributed}')
+    logger.info(f'Config:\n{cfg.pretty_text}')
+
+    # set random seeds
+    if args.seed is not None:
+        logger.info(f'Set random seed to {args.seed}, '
+                    f'deterministic: {args.deterministic}')
+        set_random_seed(args.seed, deterministic=args.deterministic)
+    cfg.seed = args.seed
+    meta['seed'] = args.seed
+
+    model = build_classifier(cfg.model)
+    model.init_weights()
+
+    datasets = [build_dataset(cfg.data.train)]
+    if len(cfg.workflow) == 2:
+        val_dataset = copy.deepcopy(cfg.data.val)
+        val_dataset.pipeline = cfg.data.train.pipeline
+        datasets.append(build_dataset(val_dataset))
+    if cfg.checkpoint_config is not None:
+        # save mmcls version, config file content and class names in
+        # checkpoints as meta data
+        cfg.checkpoint_config.meta = dict(
+            mmcls_version=__version__,
+            config=cfg.pretty_text,
+            CLASSES=datasets[0].CLASSES)
+    # add an attribute for visualization convenience
+    train_model(
+        model,
+        datasets,
+        cfg,
+        distributed=distributed,
+        validate=(not args.no_validate),
+        timestamp=timestamp,
+        device='cpu' if args.device == 'cpu' else 'cuda',
+        meta=meta)
+
+
+if __name__ == '__main__':
+    main()

openmmlab_test/mmclassification-speed-benchmark/train.md

+# MMClassification算例测试
+
+## 测试前准备
+### 数据集准备
+使用dummy数据集。
+### 环境部署
+```python
+yum install python3
+yum install libquadmath
+yum install numactl
+yum install openmpi3
+yum install glog
+yum install lmdb-libs
+yum install opencv-core
+yum install opencv
+yum install openblas-serial
+pip3 install --upgrade pip
+pip3 install opencv-python
+```
+### 安装python依赖包
+```python
+pip3 install torch-1.10.0a0+gitcc7c9c7-cp36-cp36m-linux_x86_64.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+pip3 install torchvision-0.10.0a0+300a8a4-cp36-cp36m-linux_x86_64.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+pip3 install mmcv_full-1.3.16-cp36-cp36m-linux_x86_64.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+mmcls 安装：
+cd mmclassification
+pip3 install -e .
+```
+注：测试不同版本的dtk，需安装对应版本的库whl包，dtk22.04.1使用python3.7，dtk21.10.1使用python3.6
+## ResNet18测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh configs/speed_test/resnet18_b32x8_imagenet.py
+```
+若使用dtk22.04.1测试，需设置`export MIOPEN_FIND_MODE=1，export MIOPEN_USE_APPROXIMATE_PERFORMANCE=0`以下测试均相同.
+
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs32.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1](image/train/1659061854685.png)
+#### 性能关注：time
+![1659062180839](image/train/1659062180839.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/resnet18_b32x8_imagenet.py
+```
+### 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/resnet18_b32x8_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/resnet18_b32x8_fp16_imagenet.py
+```
+## ResNet34测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh configs/speed_test/resnet34_b32x8_imagenet.py
+```
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs32.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064427635](image/train/1659064427635.png)
+#### 性能关注：time
+![1659064222206](image/train/1659064222206.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/resnet34_b32x8_imagenet.py
+```
+### 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/resnet34_b32x8_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/resnet34_b32x8_fp16_imagenet.py
+```
+## ResNet50测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh configs/speed_test/resnet50_b32x8_imagenet.py
+```
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs32.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064905610](image/train/1659064905610.png)
+#### 性能关注：time
+![1659064925468](image/train/1659064925468.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/resnet50_b32x8_imagenet.py
+```
+### 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/resnet50_b32x8_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/resnet50_b32x8_fp16_imagenet.py
+```
+## ResNet152测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh configs/speed_test/resnet152_b32x8_imagenet.py
+```
+
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs32.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064905610](image/train/1659064905610.png)
+#### 性能关注：time
+![1659065333529](image/train/1659065333529.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/resnet152_b32x8_imagenet.py
+```
+### 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/resnet152_b32x8_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/resnet152_b32x8_fp16_imagenet.py
+```
+## Vgg11测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh configs/speed_test/vgg11_b32x8_imagenet.py
+```
+
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs32.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064905610](image/train/1659064905610.png)
+#### 性能关注：time
+![1659065333529](image/train/1659065333529.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/vgg11_b32x8_imagenet.py
+```
+### 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/vgg11_b32x8_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/vgg11_b32x8_fp16_imagenet.py
+```
+## SeresNet50测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh configs/speed_test/seresnet50_b32x8_imagenet.py
+```
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs32.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064905610](image/train/1659064905610.png)
+#### 性能关注：time
+![1659065659769](image/train/1659065659769.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/seresnet50_b32x8_imagenet.py
+```
+### 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/seresnet50_b32x8_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/seresnet50_b32x8_fp16_imagenet.py
+```
+## ResNext50测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh configs/speed_test/resnext50_32x4d_b32x8_imagenet.py
+```
+
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs32.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064905610](image/train/1659064905610.png)
+#### 性能关注：time
+![1659065746317](image/train/1659065746317.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/resnext50_32x4d_b32x8_imagenet.py
+```
+### 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/resnext50_32x4d_b32x8_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/resnext50_32x4d_b32x8_fp16_imagenet.py
+```
+## MobileNet-v2测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh  configs/speed_test/mobilenet_v2_b32x8_imagenet.py
+```
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs32.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064905610](image/train/1659064905610.png)
+#### 性能关注：time
+![1659065746317](image/train/1659065746317.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/mobilenet_v2_b32x8_imagenet.py
+```
+### 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/mobilenet_v2_b32x8_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/mobilenet_v2_b32x8_fp16_imagenet.py
+```
+## ShuffleNet-v1测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh  configs/speed_test/shufflenet_v1_1x_b64x16_linearlr_bn_nowd_imagenet.py
+```
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs64.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064905610](image/train/1659064905610.png)
+#### 性能关注：time
+![1659066120939](image/train/1659066120939.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/shufflenet_v1_1x_b64x16_linearlr_bn_nowd_imagenet.py
+```
+## 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/shufflenet_v1_1x_b64x16_linearlr_bn_nowd_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/shufflenet_v1_1x_b64x16_linearlr_bn_nowd_fp16_imagenet.py
+```
+## ShuffleNet-v2测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh  configs/speed_test/shufflenet_v2_1x_b64x16_linearlr_bn_nowd_imagenet.py
+```
+
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs64.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064905610](image/train/1659064905610.png)
+#### 性能关注：time
+![1659066120939](image/train/1659066120939.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/speed_test/shufflenet_v2_1x_b64x16_linearlr_bn_nowd_imagenet.py
+```
+### 单卡测试（半精度）
+```python
+./sing_test.sh configs/speed_test/shufflenet_v2_1x_b64x16_linearlr_bn_nowd_fp16_imagenet.py
+```
+### 多卡测试（半精度）
+```python
+./multi_test.sh configs/speed_test/shufflenet_v2_1x_b64x16_linearlr_bn_nowd_fp16_imagenet.py
+```
+## Vgg16测试
+### 单卡测试（单精度）
+```python
+./sing_test.sh configs/vgg/vgg16_b32x8_imagenet.py
+```
+#### 参数说明
+configs/speed_test/datasets/imagenet_bs32.py 中batch_size=samples_per_gpu*卡数,性能计算方法：batch_size/time
+![1659064905610](image/train/1659064905610.png)
+#### 性能关注：time
+![1659067079718](image/train/1659067079718.png)
+### 多卡测试（单精度）
+```python
+./multi_test.sh configs/vgg/vgg16_b32x8_imagenet.py
+```
\ No newline at end of file

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/batch_test_list.py

+# yapf: disable
+atss = dict(
+    config='configs/atss/atss_r50_fpn_1x_coco.py',
+    checkpoint='atss_r50_fpn_1x_coco_20200209-985f7bd0.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=39.4),
+)
+autoassign = dict(
+    config='configs/autoassign/autoassign_r50_fpn_8x2_1x_coco.py',
+    checkpoint='auto_assign_r50_fpn_1x_coco_20210413_115540-5e17991f.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=40.4),
+)
+carafe = dict(
+    config='configs/carafe/faster_rcnn_r50_fpn_carafe_1x_coco.py',
+    checkpoint='faster_rcnn_r50_fpn_carafe_1x_coco_bbox_mAP-0.386_20200504_175733-385a75b7.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=38.6),
+)
+cascade_rcnn = [
+    dict(
+        config='configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.py',
+        checkpoint='cascade_rcnn_r50_fpn_1x_coco_20200316-3dc56deb.pth',
+        eval='bbox',
+        metric=dict(bbox_mAP=40.3),
+    ),
+    dict(
+        config='configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py',
+        checkpoint='cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth',
+        eval=['bbox', 'segm'],
+        metric=dict(bbox_mAP=41.2, segm_mAP=35.9),
+    ),
+]
+cascade_rpn = dict(
+    config='configs/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco.py',
+    checkpoint='crpn_faster_rcnn_r50_caffe_fpn_1x_coco-c8283cca.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=40.4),
+)
+centripetalnet = dict(
+    config='configs/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco.py',  # noqa
+    checkpoint='centripetalnet_hourglass104_mstest_16x6_210e_coco_20200915_204804-3ccc61e5.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=44.7),
+)
+cornernet = dict(
+    config='configs/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco.py',
+    checkpoint='cornernet_hourglass104_mstest_10x5_210e_coco_20200824_185720-5fefbf1c.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=41.2),
+)
+dcn = dict(
+    config='configs/dcn/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco.py',
+    checkpoint='faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130-d68aed1e.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=41.3),
+)
+deformable_detr = dict(
+    config='configs/deformable_detr/deformable_detr_r50_16x2_50e_coco.py',
+    checkpoint='deformable_detr_r50_16x2_50e_coco_20210419_220030-a12b9512.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=44.5),
+)
+detectors = dict(
+    config='configs/detectors/detectors_htc_r50_1x_coco.py',
+    checkpoint='detectors_htc_r50_1x_coco-329b1453.pth',
+    eval=['bbox', 'segm'],
+    metric=dict(bbox_mAP=49.1, segm_mAP=42.6),
+)
+detr = dict(
+    config='configs/detr/detr_r50_8x2_150e_coco.py',
+    checkpoint='detr_r50_8x2_150e_coco_20201130_194835-2c4b8974.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=40.1),
+)
+double_heads = dict(
+    config='configs/double_heads/dh_faster_rcnn_r50_fpn_1x_coco.py',
+    checkpoint='dh_faster_rcnn_r50_fpn_1x_coco_20200130-586b67df.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=40.0),
+)
+dynamic_rcnn = dict(
+    config='configs/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x_coco.py',
+    checkpoint='dynamic_rcnn_r50_fpn_1x-62a3f276.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=38.9),
+)
+empirical_attention = dict(
+    config='configs/empirical_attention/faster_rcnn_r50_fpn_attention_1111_1x_coco.py',  # noqa
+    checkpoint='faster_rcnn_r50_fpn_attention_1111_1x_coco_20200130-403cccba.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=40.0),
+)
+faster_rcnn = dict(
+    config='configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py',
+    checkpoint='faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=37.4),
+)
+fcos = dict(
+    config='configs/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco.py',  # noqa
+    checkpoint='fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco-0a0d75a8.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=38.7),
+)
+foveabox = dict(
+    config='configs/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco.py',
+    checkpoint='fovea_align_r50_fpn_gn-head_4x4_2x_coco_20200203-8987880d.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=37.9),
+)
+free_anchor = dict(
+    config='configs/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco.py',
+    checkpoint='retinanet_free_anchor_r50_fpn_1x_coco_20200130-0f67375f.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=38.7),
+)
+fsaf = dict(
+    config='configs/fsaf/fsaf_r50_fpn_1x_coco.py',
+    checkpoint='fsaf_r50_fpn_1x_coco-94ccc51f.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=37.4),
+)
+gcnet = dict(
+    config='configs/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco.py',  # noqa
+    checkpoint='mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200202-587b99aa.pth',  # noqa
+    eval=['bbox', 'segm'],
+    metric=dict(bbox_mAP=40.4, segm_mAP=36.2),
+)
+gfl = dict(
+    config='configs/gfl/gfl_r50_fpn_1x_coco.py',
+    checkpoint='gfl_r50_fpn_1x_coco_20200629_121244-25944287.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=40.2),
+)
+gn = dict(
+    config='configs/gn/mask_rcnn_r50_fpn_gn-all_2x_coco.py',
+    checkpoint='mask_rcnn_r50_fpn_gn-all_2x_coco_20200206-8eee02a6.pth',
+    eval=['bbox', 'segm'],
+    metric=dict(bbox_mAP=40.1, segm_mAP=36.4),
+)
+gn_ws = dict(
+    config='configs/gn+ws/faster_rcnn_r50_fpn_gn_ws-all_1x_coco.py',
+    checkpoint='faster_rcnn_r50_fpn_gn_ws-all_1x_coco_20200130-613d9fe2.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=39.7),
+)
+grid_rcnn = dict(
+    config='configs/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco.py',
+    checkpoint='grid_rcnn_r50_fpn_gn-head_2x_coco_20200130-6cca8223.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=40.4),
+)
+groie = dict(
+    config='configs/groie/faster_rcnn_r50_fpn_groie_1x_coco.py',
+    checkpoint='faster_rcnn_r50_fpn_groie_1x_coco_20200604_211715-66ee9516.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=38.3),
+)
+guided_anchoring = [
+    dict(
+        config='configs/guided_anchoring/ga_retinanet_r50_caffe_fpn_1x_coco.py',  # noqa
+        checkpoint='ga_retinanet_r50_caffe_fpn_1x_coco_20201020-39581c6f.pth',
+        eval='bbox',
+        metric=dict(bbox_mAP=36.9),
+    ),
+    dict(
+        config='configs/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco.py',
+        checkpoint='ga_faster_r50_caffe_fpn_1x_coco_20200702_000718-a11ccfe6.pth',  # noqa
+        eval='bbox',
+        metric=dict(bbox_mAP=39.6),
+    ),
+]
+hrnet = dict(
+    config='configs/hrnet/faster_rcnn_hrnetv2p_w18_1x_coco.py',
+    checkpoint='faster_rcnn_hrnetv2p_w18_1x_coco_20200130-56651a6d.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=36.9),
+)
+htc = dict(
+    config='configs/htc/htc_r50_fpn_1x_coco.py',
+    checkpoint='htc_r50_fpn_1x_coco_20200317-7332cf16.pth',
+    eval=['bbox', 'segm'],
+    metric=dict(bbox_mAP=42.3, segm_mAP=37.4),
+)
+libra_rcnn = dict(
+    config='configs/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco.py',
+    checkpoint='libra_faster_rcnn_r50_fpn_1x_coco_20200130-3afee3a9.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=38.3),
+)
+mask_rcnn = dict(
+    config='configs/mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py',
+    checkpoint='mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth',
+    eval=['bbox', 'segm'],
+    metric=dict(bbox_mAP=38.2, segm_mAP=34.7),
+)
+ms_rcnn = dict(
+    config='configs/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco.py',
+    checkpoint='ms_rcnn_r50_caffe_fpn_1x_coco_20200702_180848-61c9355e.pth',
+    eval=['bbox', 'segm'],
+    metric=dict(bbox_mAP=38.2, segm_mAP=36.0),
+)
+nas_fcos = dict(
+    config='configs/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco.py',  # noqa
+    checkpoint='nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200520-1bdba3ce.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=39.4),
+)
+nas_fpn = dict(
+    config='configs/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco.py',
+    checkpoint='retinanet_r50_nasfpn_crop640_50e_coco-0ad1f644.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=40.5),
+)
+paa = dict(
+    config='configs/paa/paa_r50_fpn_1x_coco.py',
+    checkpoint='paa_r50_fpn_1x_coco_20200821-936edec3.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=40.4),
+)
+pafpn = dict(
+    config='configs/pafpn/faster_rcnn_r50_pafpn_1x_coco.py',
+    checkpoint='faster_rcnn_r50_pafpn_1x_coco_bbox_mAP-0.375_20200503_105836-b7b4b9bd.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=37.5),
+)
+pisa = dict(
+    config='configs/pisa/pisa_faster_rcnn_r50_fpn_1x_coco.py',
+    checkpoint='pisa_faster_rcnn_r50_fpn_1x_coco-dea93523.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=38.4),
+)
+point_rend = dict(
+    config='configs/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco.py',
+    checkpoint='point_rend_r50_caffe_fpn_mstrain_1x_coco-1bcb5fb4.pth',
+    eval=['bbox', 'segm'],
+    metric=dict(bbox_mAP=38.4, segm_mAP=36.3),
+)
+regnet = dict(
+    config='configs/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco.py',
+    checkpoint='mask_rcnn_regnetx-3.2GF_fpn_1x_coco_20200520_163141-2a9d1814.pth',  # noqa
+    eval=['bbox', 'segm'],
+    metric=dict(bbox_mAP=40.4, segm_mAP=36.7),
+)
+reppoints = dict(
+    config='configs/reppoints/reppoints_moment_r50_fpn_1x_coco.py',
+    checkpoint='reppoints_moment_r50_fpn_1x_coco_20200330-b73db8d1.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=37.0),
+)
+res2net = dict(
+    config='configs/res2net/faster_rcnn_r2_101_fpn_2x_coco.py',
+    checkpoint='faster_rcnn_r2_101_fpn_2x_coco-175f1da6.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=43.0),
+)
+resnest = dict(
+    config='configs/resnest/faster_rcnn_s50_fpn_syncbn-backbone+head_mstrain-range_1x_coco.py',  # noqa
+    checkpoint='faster_rcnn_s50_fpn_syncbn-backbone+head_mstrain-range_1x_coco_20200926_125502-20289c16.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=42.0),
+)
+retinanet = dict(
+    config='configs/retinanet/retinanet_r50_fpn_1x_coco.py',
+    checkpoint='retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=36.5),
+)
+rpn = dict(
+    config='configs/rpn/rpn_r50_fpn_1x_coco.py',
+    checkpoint='rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth',
+    eval='proposal_fast',
+    metric=dict(AR_1000=58.2),
+)
+sabl = [
+    dict(
+        config='configs/sabl/sabl_retinanet_r50_fpn_1x_coco.py ',
+        checkpoint='sabl_retinanet_r50_fpn_1x_coco-6c54fd4f.pth',
+        eval='bbox',
+        metric=dict(bbox_mAP=37.7),
+    ),
+    dict(
+        config='configs/sabl/sabl_faster_rcnn_r50_fpn_1x_coco.py',
+        checkpoint='sabl_faster_rcnn_r50_fpn_1x_coco-e867595b.pth',
+        eval='bbox',
+        metric=dict(bbox_mAP=39.9),
+    ),
+]
+scnet = dict(
+    config='configs/scnet/scnet_r50_fpn_1x_coco.py',
+    checkpoint='scnet_r50_fpn_1x_coco-c3f09857.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=43.5),
+)
+sparse_rcnn = dict(
+    config='configs/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco.py',
+    checkpoint='sparse_rcnn_r50_fpn_1x_coco_20201222_214453-dc79b137.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=37.9),
+)
+ssd = dict(
+    config='configs/ssd/ssd300_coco.py',
+    checkpoint='ssd300_coco_20200307-a92d2092.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=25.6),
+)
+tridentnet = dict(
+    config='configs/tridentnet/tridentnet_r50_caffe_1x_coco.py',
+    checkpoint='tridentnet_r50_caffe_1x_coco_20201230_141838-2ec0b530.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=37.6),
+)
+vfnet = dict(
+    config='configs/vfnet/vfnet_r50_fpn_1x_coco.py',
+    checkpoint='vfnet_r50_fpn_1x_coco_20201027-38db6f58.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=41.6),
+)
+yolact = dict(
+    config='configs/yolact/yolact_r50_1x8_coco.py',
+    checkpoint='yolact_r50_1x8_coco_20200908-f38d58df.pth',
+    eval=['bbox', 'segm'],
+    metric=dict(bbox_mAP=31.2, segm_mAP=29.0),
+)
+yolo = dict(
+    config='configs/yolo/yolov3_d53_320_273e_coco.py',
+    checkpoint='yolov3_d53_320_273e_coco-421362b6.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=27.9),
+)
+yolof = dict(
+    config='configs/yolof/yolof_r50_c5_8x8_1x_coco.py',
+    checkpoint='yolof_r50_c5_8x8_1x_coco_20210425_024427-8e864411.pth',
+    eval='bbox',
+    metric=dict(bbox_mAP=37.5),
+)
+centernet = dict(
+    config='configs/centernet/centernet_resnet18_dcnv2_140e_coco.py',
+    checkpoint='centernet_resnet18_dcnv2_140e_coco_20210520_101209-da388ba2.pth',  # noqa
+    eval='bbox',
+    metric=dict(bbox_mAP=29.5),
+)
+# yapf: enable

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/batch_train_list.txt

+configs/atss/atss_r50_fpn_1x_coco.py
+configs/autoassign/autoassign_r50_fpn_8x2_1x_coco.py
+configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py
+configs/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco.py
+configs/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco.py
+configs/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco.py
+configs/detectors/detectors_htc_r50_1x_coco.py
+configs/deformable_detr/deformable_detr_r50_16x2_50e_coco.py
+configs/detr/detr_r50_8x2_150e_coco.py
+configs/double_heads/dh_faster_rcnn_r50_fpn_1x_coco.py
+configs/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x_coco.py
+configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py
+configs/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco.py
+configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco.py
+configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_1x_coco.py
+configs/faster_rcnn/faster_rcnn_r50_fpn_ohem_1x_coco.py
+configs/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco.py
+configs/fp16/mask_rcnn_r50_fpn_fp16_1x_coco.py
+configs/fp16/retinanet_r50_fpn_fp16_1x_coco.py
+configs/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco.py
+configs/fsaf/fsaf_r50_fpn_1x_coco.py
+configs/gfl/gfl_r50_fpn_1x_coco.py
+configs/ghm/retinanet_ghm_r50_fpn_1x_coco.py
+configs/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco.py
+configs/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco.py
+configs/htc/htc_r50_fpn_1x_coco.py
+configs/ld/ld_r18_gflv1_r101_fpn_coco_1x.py
+configs/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco.py
+configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco.py
+configs/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco.py
+configs/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco.py
+configs/paa/paa_r50_fpn_1x_coco.py
+configs/pisa/pisa_mask_rcnn_r50_fpn_1x_coco.py
+configs/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco.py
+configs/reppoints/reppoints_moment_r50_fpn_gn-neck+head_1x_coco.py
+configs/retinanet/retinanet_r50_caffe_fpn_1x_coco.py
+configs/rpn/rpn_r50_fpn_1x_coco.py
+configs/sabl/sabl_retinanet_r50_fpn_1x_coco.py
+configs/ssd/ssd300_coco.py
+configs/tridentnet/tridentnet_r50_caffe_1x_coco.py
+configs/vfnet/vfnet_r50_fpn_1x_coco.py
+configs/yolact/yolact_r50_1x8_coco.py
+configs/yolo/yolov3_d53_320_273e_coco.py
+configs/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco.py
+configs/scnet/scnet_r50_fpn_1x_coco.py
+configs/yolof/yolof_r50_c5_8x8_1x_coco.py
+configs/carafe/mask_rcnn_r50_fpn_carafe_1x_coco.py
+configs/dcn/faster_rcnn_r50_fpn_mdpool_1x_coco.py
+configs/dcn/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco.py
+configs/dcn/faster_rcnn_r50_fpn_dpool_1x_coco.py
+configs/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco.py
+configs/empirical_attention/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco.py
+configs/gcnet/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco.py
+configs/gn/mask_rcnn_r50_fpn_gn-all_2x_coco.py
+configs/gn+ws/mask_rcnn_r50_fpn_gn_ws-all_2x_coco.py
+configs/hrnet/mask_rcnn_hrnetv2p_w18_1x_coco.py
+configs/pafpn/faster_rcnn_r50_pafpn_1x_coco.py
+configs/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco.py
+configs/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco.py
+configs/resnest/mask_rcnn_s50_fpn_syncbn-backbone+head_mstrain_1x_coco.py
+configs/res2net/faster_rcnn_r2_101_fpn_2x_coco.py
+configs/groie/faster_rcnn_r50_fpn_groie_1x_coco.py
+configs/centernet/centernet_resnet18_dcnv2_140e_coco.py

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/benchmark_filter.py

+import argparse
+import os
+import os.path as osp
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Filter configs to train')
+    parser.add_argument(
+        '--basic-arch',
+        action='store_true',
+        help='to train models in basic arch')
+    parser.add_argument(
+        '--datasets', action='store_true', help='to train models in dataset')
+    parser.add_argument(
+        '--data-pipeline',
+        action='store_true',
+        help='to train models related to data pipeline, e.g. augmentations')
+    parser.add_argument(
+        '--nn-module',
+        action='store_true',
+        help='to train models related to neural network modules')
+    parser.add_argument(
+        '--model-options',
+        nargs='+',
+        help='custom options to special model benchmark')
+    parser.add_argument(
+        '--out',
+        type=str,
+        default='batch_train_list.txt',
+        help='output path of gathered metrics to be stored')
+    args = parser.parse_args()
+    return args
+
+
+basic_arch_root = [
+    'atss', 'autoassign', 'cascade_rcnn', 'cascade_rpn', 'centripetalnet',
+    'cornernet', 'detectors', 'deformable_detr', 'detr', 'double_heads',
+    'dynamic_rcnn', 'faster_rcnn', 'fcos', 'foveabox', 'fp16', 'free_anchor',
+    'fsaf', 'gfl', 'ghm', 'grid_rcnn', 'guided_anchoring', 'htc', 'ld',
+    'libra_rcnn', 'mask_rcnn', 'ms_rcnn', 'nas_fcos', 'paa', 'pisa',
+    'point_rend', 'reppoints', 'retinanet', 'rpn', 'sabl', 'ssd', 'tridentnet',
+    'vfnet', 'yolact', 'yolo', 'sparse_rcnn', 'scnet', 'yolof', 'centernet'
+]
+
+datasets_root = [
+    'wider_face', 'pascal_voc', 'cityscapes', 'lvis', 'deepfashion'
+]
+
+data_pipeline_root = ['albu_example', 'instaboost']
+
+nn_module_root = [
+    'carafe', 'dcn', 'empirical_attention', 'gcnet', 'gn', 'gn+ws', 'hrnet',
+    'pafpn', 'nas_fpn', 'regnet', 'resnest', 'res2net', 'groie'
+]
+
+benchmark_pool = [
+    'configs/albu_example/mask_rcnn_r50_fpn_albu_1x_coco.py',
+    'configs/atss/atss_r50_fpn_1x_coco.py',
+    'configs/autoassign/autoassign_r50_fpn_8x2_1x_coco.py',
+    'configs/carafe/mask_rcnn_r50_fpn_carafe_1x_coco.py',
+    'configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py',
+    'configs/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco.py',
+    'configs/centernet/centernet_resnet18_dcnv2_140e_coco.py',
+    'configs/centripetalnet/'
+    'centripetalnet_hourglass104_mstest_16x6_210e_coco.py',
+    'configs/cityscapes/mask_rcnn_r50_fpn_1x_cityscapes.py',
+    'configs/cornernet/'
+    'cornernet_hourglass104_mstest_8x6_210e_coco.py',
+    'configs/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco.py',
+    'configs/dcn/faster_rcnn_r50_fpn_dpool_1x_coco.py',
+    'configs/dcn/faster_rcnn_r50_fpn_mdpool_1x_coco.py',
+    'configs/dcn/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco.py',
+    'configs/deformable_detr/deformable_detr_r50_16x2_50e_coco.py',
+    'configs/detectors/detectors_htc_r50_1x_coco.py',
+    'configs/detr/detr_r50_8x2_150e_coco.py',
+    'configs/double_heads/dh_faster_rcnn_r50_fpn_1x_coco.py',
+    'configs/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x_coco.py',
+    'configs/empirical_attention/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco.py',  # noqa
+    'configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py',
+    'configs/faster_rcnn/faster_rcnn_r50_fpn_ohem_1x_coco.py',
+    'configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_1x_coco.py',
+    'configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco.py',
+    'configs/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco.py',
+    'configs/fcos/fcos_center_r50_caffe_fpn_gn-head_4x4_1x_coco.py',
+    'configs/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco.py',
+    'configs/fp16/retinanet_r50_fpn_fp16_1x_coco.py',
+    'configs/fp16/mask_rcnn_r50_fpn_fp16_1x_coco.py',
+    'configs/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco.py',
+    'configs/fsaf/fsaf_r50_fpn_1x_coco.py',
+    'configs/gcnet/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco.py',
+    'configs/gfl/gfl_r50_fpn_1x_coco.py',
+    'configs/ghm/retinanet_ghm_r50_fpn_1x_coco.py',
+    'configs/gn/mask_rcnn_r50_fpn_gn-all_2x_coco.py',
+    'configs/gn+ws/mask_rcnn_r50_fpn_gn_ws-all_2x_coco.py',
+    'configs/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco.py',
+    'configs/groie/faster_rcnn_r50_fpn_groie_1x_coco.py',
+    'configs/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco.py',
+    'configs/hrnet/mask_rcnn_hrnetv2p_w18_1x_coco.py',
+    'configs/htc/htc_r50_fpn_1x_coco.py',
+    'configs/instaboost/mask_rcnn_r50_fpn_instaboost_4x_coco.py',
+    'configs/ld/ld_r18_gflv1_r101_fpn_coco_1x.py',
+    'configs/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco.py',
+    'configs/lvis/mask_rcnn_r50_fpn_sample1e-3_mstrain_1x_lvis_v1.py',
+    'configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco.py',
+    'configs/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco.py',
+    'configs/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco.py',
+    'configs/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco.py',
+    'configs/paa/paa_r50_fpn_1x_coco.py',
+    'configs/pafpn/faster_rcnn_r50_pafpn_1x_coco.py',
+    'configs/pisa/pisa_mask_rcnn_r50_fpn_1x_coco.py',
+    'configs/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco.py',
+    'configs/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco.py',
+    'configs/reppoints/reppoints_moment_r50_fpn_gn-neck+head_1x_coco.py',
+    'configs/res2net/faster_rcnn_r2_101_fpn_2x_coco.py',
+    'configs/resnest/'
+    'mask_rcnn_s50_fpn_syncbn-backbone+head_mstrain_1x_coco.py',
+    'configs/retinanet/retinanet_r50_caffe_fpn_1x_coco.py',
+    'configs/rpn/rpn_r50_fpn_1x_coco.py',
+    'configs/sabl/sabl_retinanet_r50_fpn_1x_coco.py',
+    'configs/ssd/ssd300_coco.py',
+    'configs/tridentnet/tridentnet_r50_caffe_1x_coco.py',
+    'configs/vfnet/vfnet_r50_fpn_1x_coco.py',
+    'configs/yolact/yolact_r50_1x8_coco.py',
+    'configs/yolo/yolov3_d53_320_273e_coco.py',
+    'configs/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco.py',
+    'configs/scnet/scnet_r50_fpn_1x_coco.py',
+    'configs/yolof/yolof_r50_c5_8x8_1x_coco.py',
+]
+
+
+def main():
+    args = parse_args()
+
+    benchmark_type = []
+    if args.basic_arch:
+        benchmark_type += basic_arch_root
+    if args.datasets:
+        benchmark_type += datasets_root
+    if args.data_pipeline:
+        benchmark_type += data_pipeline_root
+    if args.nn_module:
+        benchmark_type += nn_module_root
+
+    special_model = args.model_options
+    if special_model is not None:
+        benchmark_type += special_model
+
+    config_dpath = 'configs/'
+    benchmark_configs = []
+    for cfg_root in benchmark_type:
+        cfg_dir = osp.join(config_dpath, cfg_root)
+        configs = os.scandir(cfg_dir)
+        for cfg in configs:
+            config_path = osp.join(cfg_dir, cfg.name)
+            if (config_path in benchmark_pool
+                    and config_path not in benchmark_configs):
+                benchmark_configs.append(config_path)
+
+    print(f'Totally found {len(benchmark_configs)} configs to benchmark')
+    with open(args.out, 'w') as f:
+        for config in benchmark_configs:
+            f.write(config + '\n')
+
+
+if __name__ == '__main__':
+    main()

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/benchmark_inference_fps.py

+import argparse
+import os
+import os.path as osp
+
+import mmcv
+from mmcv import Config, DictAction
+from mmcv.runner import init_dist
+from tools.analysis_tools.benchmark import measure_inferense_speed
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='MMDet benchmark a model of FPS')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('checkpoint_root', help='Checkpoint file root path')
+    parser.add_argument(
+        '--round-num',
+        type=int,
+        default=1,
+        help='round a number to a given precision in decimal digits')
+    parser.add_argument(
+        '--out', type=str, help='output path of gathered fps to be stored')
+    parser.add_argument(
+        '--max-iter', type=int, default=400, help='num of max iter')
+    parser.add_argument(
+        '--log-interval', type=int, default=40, help='interval of logging')
+    parser.add_argument(
+        '--fuse-conv-bn',
+        action='store_true',
+        help='Whether to fuse conv and bn, this will slightly increase'
+        'the inference speed')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    parser.add_argument(
+        '--launcher',
+        choices=['none', 'pytorch', 'slurm', 'mpi'],
+        default='none',
+        help='job launcher')
+    parser.add_argument('--local_rank', type=int, default=0)
+    args = parser.parse_args()
+    if 'LOCAL_RANK' not in os.environ:
+        os.environ['LOCAL_RANK'] = str(args.local_rank)
+    return args
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    assert args.round_num >= 0
+
+    config = Config.fromfile(args.config)
+
+    if args.launcher == 'none':
+        raise NotImplementedError('Only supports distributed mode')
+    else:
+        init_dist(args.launcher)
+
+    result_dict = {}
+    for model_key in config:
+        model_infos = config[model_key]
+        if not isinstance(model_infos, list):
+            model_infos = [model_infos]
+        for model_info in model_infos:
+            record_metrics = model_info['metric']
+            cfg_path = model_info['config'].strip()
+            cfg = Config.fromfile(cfg_path)
+            checkpoint = osp.join(args.checkpoint_root,
+                                  model_info['checkpoint'].strip())
+            try:
+                fps = measure_inferense_speed(cfg, checkpoint, args.max_iter,
+                                              args.log_interval,
+                                              args.fuse_conv_bn)
+                print(
+                    f'{cfg_path} fps : {fps:.{args.round_num}f} img / s, '
+                    f'times per image: {1000/fps:.{args.round_num}f} ms / img',
+                    flush=True)
+                result_dict[cfg_path] = dict(
+                    fps=round(fps, args.round_num),
+                    ms_times_pre_image=round(1000 / fps, args.round_num))
+            except Exception as e:
+                print(f'{config} error: {repr(e)}')
+                result_dict[cfg_path] = 0
+
+    if args.out:
+        mmcv.mkdir_or_exist(args.out)
+        mmcv.dump(result_dict, osp.join(args.out, 'batch_inference_fps.json'))

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/benchmark_test_image.py

+import logging
+import os.path as osp
+from argparse import ArgumentParser
+
+from mmcv import Config
+
+from mmdet.apis import inference_detector, init_detector, show_result_pyplot
+from mmdet.utils import get_root_logger
+
+
+def parse_args():
+    parser = ArgumentParser()
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('checkpoint_root', help='Checkpoint file root path')
+    parser.add_argument('--img', default='demo/demo.jpg', help='Image file')
+    parser.add_argument('--aug', action='store_true', help='aug test')
+    parser.add_argument('--show', action='store_true', help='show results')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--score-thr', type=float, default=0.3, help='bbox score threshold')
+    args = parser.parse_args()
+    return args
+
+
+# Sample test whether the inference code is correct
+def main(args):
+    config = Config.fromfile(args.config)
+    logger = get_root_logger(
+        log_file='benchmark_test_image.log', log_level=logging.ERROR)
+
+    for model_key in config:
+        model_infos = config[model_key]
+        if not isinstance(model_infos, list):
+            model_infos = [model_infos]
+        for model_info in model_infos:
+            print('processing: ', model_info['config'], flush=True)
+            config_name = model_info['config'].strip()
+            checkpoint = osp.join(args.checkpoint_root,
+                                  model_info['checkpoint'].strip())
+            try:
+                # build the model from a config file and a checkpoint file
+                cfg = Config.fromfile(config_name)
+                if args.aug:
+                    if 'flip' in cfg.data.test.pipeline[1]:
+                        cfg.data.test.pipeline[1].flip = True
+                    else:
+                        logger.error(
+                            f'{config_name} " : Unable to start aug test')
+
+                model = init_detector(cfg, checkpoint, device=args.device)
+                # test a single image
+                result = inference_detector(model, args.img)
+                # show the results
+                if args.show:
+                    show_result_pyplot(
+                        model,
+                        args.img,
+                        result,
+                        score_thr=args.score_thr,
+                        wait_time=1)
+            except Exception as e:
+                logger.error(f'{config_name} " : {repr(e)}')
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    main(args)

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/convert_test_benchmark_script.py

+import argparse
+import os
+import os.path as osp
+
+from mmcv import Config
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert benchmark model list to script')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('--port', type=int, default=29666, help='dist port')
+    parser.add_argument(
+        '--work-dir',
+        default='tools/batch_test',
+        help='the dir to save metric')
+    parser.add_argument(
+        '--run', action='store_true', help='run script directly')
+    parser.add_argument(
+        '--out', type=str, help='path to save model benchmark script')
+
+    args = parser.parse_args()
+    return args
+
+
+def process_model_info(model_info, work_dir):
+    config = model_info['config'].strip()
+    fname, _ = osp.splitext(osp.basename(config))
+    job_name = fname
+    work_dir = osp.join(work_dir, fname)
+    checkpoint = model_info['checkpoint'].strip()
+    if not isinstance(model_info['eval'], list):
+        evals = [model_info['eval']]
+    else:
+        evals = model_info['eval']
+    eval = ' '.join(evals)
+    return dict(
+        config=config,
+        job_name=job_name,
+        work_dir=work_dir,
+        checkpoint=checkpoint,
+        eval=eval)
+
+
+def create_test_bash_info(commands, model_test_dict, port, script_name,
+                          partition):
+    config = model_test_dict['config']
+    job_name = model_test_dict['job_name']
+    checkpoint = model_test_dict['checkpoint']
+    work_dir = model_test_dict['work_dir']
+    eval = model_test_dict['eval']
+
+    echo_info = f' \necho \'{config}\' &'
+    commands.append(echo_info)
+    commands.append('\n')
+
+    command_info = f'GPUS=8  GPUS_PER_NODE=8  ' \
+                   f'CPUS_PER_TASK=2 {script_name} '
+
+    command_info += f'{partition} '
+    command_info += f'{job_name} '
+    command_info += f'{config} '
+    command_info += f'$CHECKPOINT_DIR/{checkpoint} '
+    command_info += f'--work-dir {work_dir} '
+
+    command_info += f'--eval {eval} '
+    command_info += f'--cfg-option dist_params.port={port} '
+    command_info += ' &'
+
+    commands.append(command_info)
+
+
+def main():
+    args = parse_args()
+    if args.out:
+        out_suffix = args.out.split('.')[-1]
+        assert args.out.endswith('.sh'), \
+            f'Expected out file path suffix is .sh, but get .{out_suffix}'
+    assert args.out or args.run, \
+        ('Please specify at least one operation (save/run/ the '
+         'script) with the argument "--out" or "--run"')
+
+    commands = []
+    partition_name = 'PARTITION=$1 '
+    commands.append(partition_name)
+    commands.append('\n')
+
+    checkpoint_root = 'CHECKPOINT_DIR=$2 '
+    commands.append(checkpoint_root)
+    commands.append('\n')
+
+    script_name = osp.join('tools', 'slurm_test.sh')
+    port = args.port
+    work_dir = args.work_dir
+
+    cfg = Config.fromfile(args.config)
+
+    for model_key in cfg:
+        model_infos = cfg[model_key]
+        if not isinstance(model_infos, list):
+            model_infos = [model_infos]
+        for model_info in model_infos:
+            print('processing: ', model_info['config'])
+            model_test_dict = process_model_info(model_info, work_dir)
+            create_test_bash_info(commands, model_test_dict, port, script_name,
+                                  '$PARTITION')
+            port += 1
+
+    command_str = ''.join(commands)
+    if args.out:
+        with open(args.out, 'w') as f:
+            f.write(command_str)
+    if args.run:
+        os.system(command_str)
+
+
+if __name__ == '__main__':
+    main()

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/convert_train_benchmark_script.py

+import argparse
+import os
+import os.path as osp
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Convert benchmark model json to script')
+    parser.add_argument(
+        'txt_path', type=str, help='txt path output by benchmark_filter')
+    parser.add_argument(
+        '--partition',
+        type=str,
+        default='openmmlab',
+        help='slurm partition name')
+    parser.add_argument(
+        '--max-keep-ckpts',
+        type=int,
+        default=1,
+        help='The maximum checkpoints to keep')
+    parser.add_argument(
+        '--run', action='store_true', help='run script directly')
+    parser.add_argument(
+        '--out', type=str, help='path to save model benchmark script')
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    if args.out:
+        out_suffix = args.out.split('.')[-1]
+        assert args.out.endswith('.sh'), \
+            f'Expected out file path suffix is .sh, but get .{out_suffix}'
+    assert args.out or args.run, \
+        ('Please specify at least one operation (save/run/ the '
+         'script) with the argument "--out" or "--run"')
+
+    partition = args.partition  # cluster name
+
+    root_name = './tools'
+    train_script_name = osp.join(root_name, 'slurm_train.sh')
+    # stdout is no output
+    stdout_cfg = '>/dev/null'
+
+    max_keep_ckpts = args.max_keep_ckpts
+
+    commands = []
+    with open(args.txt_path, 'r') as f:
+        model_cfgs = f.readlines()
+        for i, cfg in enumerate(model_cfgs):
+            cfg = cfg.strip()
+            if len(cfg) == 0:
+                continue
+            # print cfg name
+            echo_info = f'echo \'{cfg}\' &'
+            commands.append(echo_info)
+            commands.append('\n')
+
+            fname, _ = osp.splitext(osp.basename(cfg))
+            out_fname = osp.join(root_name, 'work_dir', fname)
+            # default setting
+            if cfg.find('16x') >= 0:
+                command_info = f'GPUS=16  GPUS_PER_NODE=8  ' \
+                               f'CPUS_PER_TASK=2 {train_script_name} '
+            elif cfg.find('gn-head_4x4_1x_coco.py') >= 0 or \
+                    cfg.find('gn-head_4x4_2x_coco.py') >= 0:
+                command_info = f'GPUS=4  GPUS_PER_NODE=4  ' \
+                               f'CPUS_PER_TASK=2 {train_script_name} '
+            else:
+                command_info = f'GPUS=8  GPUS_PER_NODE=8  ' \
+                               f'CPUS_PER_TASK=2 {train_script_name} '
+            command_info += f'{partition} '
+            command_info += f'{fname} '
+            command_info += f'{cfg} '
+            command_info += f'{out_fname} '
+            if max_keep_ckpts:
+                command_info += f'--cfg-options ' \
+                                f'checkpoint_config.max_keep_ckpts=' \
+                                f'{max_keep_ckpts}' + ' '
+            command_info += f'{stdout_cfg} &'
+
+            commands.append(command_info)
+
+            if i < len(model_cfgs):
+                commands.append('\n')
+
+        command_str = ''.join(commands)
+        if args.out:
+            with open(args.out, 'w') as f:
+                f.write(command_str)
+        if args.run:
+            os.system(command_str)
+
+
+if __name__ == '__main__':
+    main()

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/gather_models.py

+import argparse
+import glob
+import json
+import os.path as osp
+import shutil
+import subprocess
+from collections import OrderedDict
+
+import mmcv
+import torch
+import yaml
+
+
+def ordered_yaml_dump(data, stream=None, Dumper=yaml.SafeDumper, **kwds):
+
+    class OrderedDumper(Dumper):
+        pass
+
+    def _dict_representer(dumper, data):
+        return dumper.represent_mapping(
+            yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, data.items())
+
+    OrderedDumper.add_representer(OrderedDict, _dict_representer)
+    return yaml.dump(data, stream, OrderedDumper, **kwds)
+
+
+def process_checkpoint(in_file, out_file):
+    checkpoint = torch.load(in_file, map_location='cpu')
+    # remove optimizer for smaller file size
+    if 'optimizer' in checkpoint:
+        del checkpoint['optimizer']
+    # if it is necessary to remove some sensitive data in checkpoint['meta'],
+    # add the code here.
+    if torch.__version__ >= '1.6':
+        torch.save(checkpoint, out_file, _use_new_zipfile_serialization=False)
+    else:
+        torch.save(checkpoint, out_file)
+    sha = subprocess.check_output(['sha256sum', out_file]).decode()
+    final_file = out_file.rstrip('.pth') + '-{}.pth'.format(sha[:8])
+    subprocess.Popen(['mv', out_file, final_file])
+    return final_file
+
+
+def get_final_epoch(config):
+    cfg = mmcv.Config.fromfile('./configs/' + config)
+    return cfg.runner.max_epochs
+
+
+def get_real_epoch(config):
+    cfg = mmcv.Config.fromfile('./configs/' + config)
+    epoch = cfg.runner.max_epochs
+    if cfg.data.train.type == 'RepeatDataset':
+        epoch *= cfg.data.train.times
+    return epoch
+
+
+def get_final_results(log_json_path, epoch, results_lut):
+    result_dict = dict()
+    with open(log_json_path, 'r') as f:
+        for line in f.readlines():
+            log_line = json.loads(line)
+            if 'mode' not in log_line.keys():
+                continue
+
+            if log_line['mode'] == 'train' and log_line['epoch'] == epoch:
+                result_dict['memory'] = log_line['memory']
+
+            if log_line['mode'] == 'val' and log_line['epoch'] == epoch:
+                result_dict.update({
+                    key: log_line[key]
+                    for key in results_lut if key in log_line
+                })
+                return result_dict
+
+
+def get_dataset_name(config):
+    # If there are more dataset, add here.
+    name_map = dict(
+        CityscapesDataset='Cityscapes',
+        CocoDataset='COCO',
+        DeepFashionDataset='Deep Fashion',
+        LVISV05Dataset='LVIS v0.5',
+        LVISV1Dataset='LVIS v1',
+        VOCDataset='Pascal VOC',
+        WIDERFaceDataset='WIDER Face')
+    cfg = mmcv.Config.fromfile('./configs/' + config)
+    return name_map[cfg.dataset_type]
+
+
+def convert_model_info_to_pwc(model_infos):
+    pwc_files = {}
+    for model in model_infos:
+        cfg_folder_name = osp.split(model['config'])[-2]
+        pwc_model_info = OrderedDict()
+        pwc_model_info['Name'] = osp.split(model['config'])[-1].split('.')[0]
+        pwc_model_info['In Collection'] = 'Please fill in Collection name'
+        pwc_model_info['Config'] = osp.join('configs', model['config'])
+
+        # get metadata
+        memory = round(model['results']['memory'] / 1024, 1)
+        epochs = get_real_epoch(model['config'])
+        meta_data = OrderedDict()
+        meta_data['Training Memory (GB)'] = memory
+        meta_data['Epochs'] = epochs
+        pwc_model_info['Metadata'] = meta_data
+
+        # get dataset name
+        dataset_name = get_dataset_name(model['config'])
+
+        # get results
+        results = []
+        # if there are more metrics, add here.
+        if 'bbox_mAP' in model['results']:
+            metric = round(model['results']['bbox_mAP'] * 100, 1)
+            results.append(
+                OrderedDict(
+                    Task='Object Detection',
+                    Dataset=dataset_name,
+                    Metrics={'box AP': metric}))
+        if 'segm_mAP' in model['results']:
+            metric = round(model['results']['segm_mAP'] * 100, 1)
+            results.append(
+                OrderedDict(
+                    Task='Instance Segmentation',
+                    Dataset=dataset_name,
+                    Metrics={'mask AP': metric}))
+        pwc_model_info['Results'] = results
+
+        link_string = 'https://download.openmmlab.com/mmdetection/v2.0/'
+        link_string += '{}/{}'.format(model['config'].rstrip('.py'),
+                                      osp.split(model['model_path'])[-1])
+        pwc_model_info['Weights'] = link_string
+        if cfg_folder_name in pwc_files:
+            pwc_files[cfg_folder_name].append(pwc_model_info)
+        else:
+            pwc_files[cfg_folder_name] = [pwc_model_info]
+    return pwc_files
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Gather benchmarked models')
+    parser.add_argument(
+        'root',
+        type=str,
+        help='root path of benchmarked models to be gathered')
+    parser.add_argument(
+        'out', type=str, help='output path of gathered models to be stored')
+
+    args = parser.parse_args()
+    return args
+
+
+def main():
+    args = parse_args()
+    models_root = args.root
+    models_out = args.out
+    mmcv.mkdir_or_exist(models_out)
+
+    # find all models in the root directory to be gathered
+    raw_configs = list(mmcv.scandir('./configs', '.py', recursive=True))
+
+    # filter configs that is not trained in the experiments dir
+    used_configs = []
+    for raw_config in raw_configs:
+        if osp.exists(osp.join(models_root, raw_config)):
+            used_configs.append(raw_config)
+    print(f'Find {len(used_configs)} models to be gathered')
+
+    # find final_ckpt and log file for trained each config
+    # and parse the best performance
+    model_infos = []
+    for used_config in used_configs:
+        exp_dir = osp.join(models_root, used_config)
+        # check whether the exps is finished
+        final_epoch = get_final_epoch(used_config)
+        final_model = 'epoch_{}.pth'.format(final_epoch)
+        model_path = osp.join(exp_dir, final_model)
+
+        # skip if the model is still training
+        if not osp.exists(model_path):
+            continue
+
+        # get the latest logs
+        log_json_path = list(
+            sorted(glob.glob(osp.join(exp_dir, '*.log.json'))))[-1]
+        log_txt_path = list(sorted(glob.glob(osp.join(exp_dir, '*.log'))))[-1]
+        cfg = mmcv.Config.fromfile('./configs/' + used_config)
+        results_lut = cfg.evaluation.metric
+        if not isinstance(results_lut, list):
+            results_lut = [results_lut]
+        # case when using VOC, the evaluation key is only 'mAP'
+        results_lut = [key + '_mAP' for key in results_lut if 'mAP' not in key]
+        model_performance = get_final_results(log_json_path, final_epoch,
+                                              results_lut)
+
+        if model_performance is None:
+            continue
+
+        model_time = osp.split(log_txt_path)[-1].split('.')[0]
+        model_infos.append(
+            dict(
+                config=used_config,
+                results=model_performance,
+                epochs=final_epoch,
+                model_time=model_time,
+                log_json_path=osp.split(log_json_path)[-1]))
+
+    # publish model for each checkpoint
+    publish_model_infos = []
+    for model in model_infos:
+        model_publish_dir = osp.join(models_out, model['config'].rstrip('.py'))
+        mmcv.mkdir_or_exist(model_publish_dir)
+
+        model_name = osp.split(model['config'])[-1].split('.')[0]
+
+        model_name += '_' + model['model_time']
+        publish_model_path = osp.join(model_publish_dir, model_name)
+        trained_model_path = osp.join(models_root, model['config'],
+                                      'epoch_{}.pth'.format(model['epochs']))
+
+        # convert model
+        final_model_path = process_checkpoint(trained_model_path,
+                                              publish_model_path)
+
+        # copy log
+        shutil.copy(
+            osp.join(models_root, model['config'], model['log_json_path']),
+            osp.join(model_publish_dir, f'{model_name}.log.json'))
+        shutil.copy(
+            osp.join(models_root, model['config'],
+                     model['log_json_path'].rstrip('.json')),
+            osp.join(model_publish_dir, f'{model_name}.log'))
+
+        # copy config to guarantee reproducibility
+        config_path = model['config']
+        config_path = osp.join(
+            'configs',
+            config_path) if 'configs' not in config_path else config_path
+        target_cconfig_path = osp.split(config_path)[-1]
+        shutil.copy(config_path,
+                    osp.join(model_publish_dir, target_cconfig_path))
+
+        model['model_path'] = final_model_path
+        publish_model_infos.append(model)
+
+    models = dict(models=publish_model_infos)
+    print(f'Totally gathered {len(publish_model_infos)} models')
+    mmcv.dump(models, osp.join(models_out, 'model_info.json'))
+
+    pwc_files = convert_model_info_to_pwc(publish_model_infos)
+    for name in pwc_files:
+        with open(osp.join(models_out, name + '_metafile.yml'), 'w') as f:
+            ordered_yaml_dump(pwc_files[name], f, encoding='utf-8')
+
+
+if __name__ == '__main__':
+    main()

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/gather_test_benchmark_metric.py

+import argparse
+import glob
+import os.path as osp
+
+import mmcv
+from mmcv import Config
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Gather benchmarked models metric')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument(
+        'root',
+        type=str,
+        help='root path of benchmarked models to be gathered')
+    parser.add_argument(
+        '--out', type=str, help='output path of gathered metrics to be stored')
+    parser.add_argument(
+        '--not-show', action='store_true', help='not show metrics')
+    parser.add_argument(
+        '--show-all', action='store_true', help='show all model metrics')
+
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+    args = parse_args()
+
+    root_path = args.root
+    metrics_out = args.out
+    result_dict = {}
+
+    cfg = Config.fromfile(args.config)
+
+    for model_key in cfg:
+        model_infos = cfg[model_key]
+        if not isinstance(model_infos, list):
+            model_infos = [model_infos]
+        for model_info in model_infos:
+            record_metrics = model_info['metric']
+            config = model_info['config'].strip()
+            fname, _ = osp.splitext(osp.basename(config))
+            metric_json_dir = osp.join(root_path, fname)
+            if osp.exists(metric_json_dir):
+                json_list = glob.glob(osp.join(metric_json_dir, '*.json'))
+                if len(json_list) > 0:
+                    log_json_path = list(sorted(json_list))[-1]
+
+                    metric = mmcv.load(log_json_path)
+                    if config in metric.get('config', {}):
+
+                        new_metrics = dict()
+                        for record_metric_key in record_metrics:
+                            record_metric_key_bk = record_metric_key
+                            old_metric = record_metrics[record_metric_key]
+                            if record_metric_key == 'AR_1000':
+                                record_metric_key = 'AR@1000'
+                            if record_metric_key not in metric['metric']:
+                                raise KeyError(
+                                    'record_metric_key not exist, please '
+                                    'check your config')
+                            new_metric = round(
+                                metric['metric'][record_metric_key] * 100, 1)
+                            new_metrics[record_metric_key_bk] = new_metric
+
+                        if args.show_all:
+                            result_dict[config] = dict(
+                                before=record_metrics, after=new_metrics)
+                        else:
+                            for record_metric_key in record_metrics:
+                                old_metric = record_metrics[record_metric_key]
+                                new_metric = new_metrics[record_metric_key]
+                                if old_metric != new_metric:
+                                    result_dict[config] = dict(
+                                        before=record_metrics,
+                                        after=new_metrics)
+                                    break
+                    else:
+                        print(f'{config} not included in: {log_json_path}')
+                else:
+                    print(f'{config} not exist file: {metric_json_dir}')
+            else:
+                print(f'{config} not exist dir: {metric_json_dir}')
+
+    if metrics_out:
+        mmcv.mkdir_or_exist(metrics_out)
+        mmcv.dump(result_dict,
+                  osp.join(metrics_out, 'batch_test_metric_info.json'))
+    if not args.not_show:
+        print('===================================')
+        for config_name, metrics in result_dict.items():
+            print(config_name, metrics)
+        print('===================================')

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/gather_train_benchmark_metric.py

+import argparse
+import glob
+import os.path as osp
+
+import mmcv
+from gather_models import get_final_results
+
+try:
+    import xlrd
+except ImportError:
+    xlrd = None
+try:
+    import xlutils
+    from xlutils.copy import copy
+except ImportError:
+    xlutils = None
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='Gather benchmarked models metric')
+    parser.add_argument(
+        'root',
+        type=str,
+        help='root path of benchmarked models to be gathered')
+    parser.add_argument(
+        'txt_path', type=str, help='txt path output by benchmark_filter')
+    parser.add_argument(
+        '--out', type=str, help='output path of gathered metrics to be stored')
+    parser.add_argument(
+        '--not-show', action='store_true', help='not show metrics')
+    parser.add_argument(
+        '--excel', type=str, help='input path of excel to be recorded')
+    parser.add_argument(
+        '--ncol', type=int, help='Number of column to be modified or appended')
+
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+    args = parse_args()
+
+    if args.excel:
+        assert args.ncol, 'Please specify "--excel" and "--ncol" ' \
+                          'at the same time'
+        if xlrd is None:
+            raise RuntimeError(
+                'xlrd is not installed,'
+                'Please use “pip install xlrd==1.2.0” to install')
+        if xlutils is None:
+            raise RuntimeError(
+                'xlutils is not installed,'
+                'Please use “pip install xlutils==2.0.0” to install')
+        readbook = xlrd.open_workbook(args.excel)
+        sheet = readbook.sheet_by_name('Sheet1')
+        sheet_info = {}
+        total_nrows = sheet.nrows
+        for i in range(3, sheet.nrows):
+            sheet_info[sheet.row_values(i)[0]] = i
+        xlrw = copy(readbook)
+        table = xlrw.get_sheet(0)
+
+    root_path = args.root
+    metrics_out = args.out
+
+    result_dict = {}
+    with open(args.txt_path, 'r') as f:
+        model_cfgs = f.readlines()
+        for i, config in enumerate(model_cfgs):
+            config = config.strip()
+            if len(config) == 0:
+                continue
+
+            config_name = osp.split(config)[-1]
+            config_name = osp.splitext(config_name)[0]
+            result_path = osp.join(root_path, config_name)
+            if osp.exists(result_path):
+                # 1 read config
+                cfg = mmcv.Config.fromfile(config)
+                total_epochs = cfg.runner.max_epochs
+                final_results = cfg.evaluation.metric
+                if not isinstance(final_results, list):
+                    final_results = [final_results]
+                final_results_out = []
+                for key in final_results:
+                    if 'proposal_fast' in key:
+                        final_results_out.append('AR@1000')  # RPN
+                    elif 'mAP' not in key:
+                        final_results_out.append(key + '_mAP')
+
+                # 2 determine whether total_epochs ckpt exists
+                ckpt_path = f'epoch_{total_epochs}.pth'
+                if osp.exists(osp.join(result_path, ckpt_path)):
+                    log_json_path = list(
+                        sorted(glob.glob(osp.join(result_path,
+                                                  '*.log.json'))))[-1]
+
+                    # 3 read metric
+                    model_performance = get_final_results(
+                        log_json_path, total_epochs, final_results_out)
+                    if model_performance is None:
+                        print(f'log file error: {log_json_path}')
+                        continue
+                    for performance in model_performance:
+                        if performance in ['AR@1000', 'bbox_mAP', 'segm_mAP']:
+                            metric = round(
+                                model_performance[performance] * 100, 1)
+                            model_performance[performance] = metric
+                    result_dict[config] = model_performance
+
+                    # update and append excel content
+                    if args.excel:
+                        if 'AR@1000' in model_performance:
+                            metrics = f'{model_performance["AR@1000"]}' \
+                                      f'(AR@1000)'
+                        elif 'segm_mAP' in model_performance:
+                            metrics = f'{model_performance["bbox_mAP"]}/' \
+                                      f'{model_performance["segm_mAP"]}'
+                        else:
+                            metrics = f'{model_performance["bbox_mAP"]}'
+
+                        row_num = sheet_info.get(config, None)
+                        if row_num:
+                            table.write(row_num, args.ncol, metrics)
+                        else:
+                            table.write(total_nrows, 0, config)
+                            table.write(total_nrows, args.ncol, metrics)
+                            total_nrows += 1
+
+                else:
+                    print(f'{config} not exist: {ckpt_path}')
+            else:
+                print(f'not exist: {config}')
+
+        # 4 save or print results
+        if metrics_out:
+            mmcv.mkdir_or_exist(metrics_out)
+            mmcv.dump(result_dict,
+                      osp.join(metrics_out, 'model_metric_info.json'))
+        if not args.not_show:
+            print('===================================')
+            for config_name, metrics in result_dict.items():
+                print(config_name, metrics)
+            print('===================================')
+        if args.excel:
+            filename, sufflx = osp.splitext(args.excel)
+            xlrw.save(f'{filename}_o{sufflx}')
+            print(f'>>> Output {filename}_o{sufflx}')

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/linter.sh

+yapf -r -i mmdet/ configs/ tests/ tools/
+isort -rc mmdet/ configs/ tests/ tools/
+flake8 .

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/test_benchamrk.sh

+PARTITION=$1
+CHECKPOINT_DIR=$2
+
+echo 'configs/atss/atss_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION atss_r50_fpn_1x_coco configs/atss/atss_r50_fpn_1x_coco.py $CHECKPOINT_DIR/atss_r50_fpn_1x_coco_20200209-985f7bd0.pth --work-dir tools/batch_test/atss_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29666  &
+echo 'configs/autoassign/autoassign_r50_fpn_8x2_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION autoassign_r50_fpn_8x2_1x_coco configs/autoassign/autoassign_r50_fpn_8x2_1x_coco.py $CHECKPOINT_DIR/auto_assign_r50_fpn_1x_coco_20210413_115540-5e17991f.pth --work-dir tools/batch_test/autoassign_r50_fpn_8x2_1x_coco --eval bbox --cfg-option dist_params.port=29667  &
+echo 'configs/carafe/faster_rcnn_r50_fpn_carafe_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_r50_fpn_carafe_1x_coco configs/carafe/faster_rcnn_r50_fpn_carafe_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_carafe_1x_coco_bbox_mAP-0.386_20200504_175733-385a75b7.pth --work-dir tools/batch_test/faster_rcnn_r50_fpn_carafe_1x_coco --eval bbox --cfg-option dist_params.port=29668  &
+echo 'configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION cascade_rcnn_r50_fpn_1x_coco configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/cascade_rcnn_r50_fpn_1x_coco_20200316-3dc56deb.pth --work-dir tools/batch_test/cascade_rcnn_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29669  &
+echo 'configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION cascade_mask_rcnn_r50_fpn_1x_coco configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth --work-dir tools/batch_test/cascade_mask_rcnn_r50_fpn_1x_coco --eval bbox segm --cfg-option dist_params.port=29670  &
+echo 'configs/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION crpn_faster_rcnn_r50_caffe_fpn_1x_coco configs/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco.py $CHECKPOINT_DIR/crpn_faster_rcnn_r50_caffe_fpn_1x_coco-c8283cca.pth --work-dir tools/batch_test/crpn_faster_rcnn_r50_caffe_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29671  &
+echo 'configs/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION centripetalnet_hourglass104_mstest_16x6_210e_coco configs/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco.py $CHECKPOINT_DIR/centripetalnet_hourglass104_mstest_16x6_210e_coco_20200915_204804-3ccc61e5.pth --work-dir tools/batch_test/centripetalnet_hourglass104_mstest_16x6_210e_coco --eval bbox --cfg-option dist_params.port=29672  &
+echo 'configs/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION cornernet_hourglass104_mstest_8x6_210e_coco configs/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco.py $CHECKPOINT_DIR/cornernet_hourglass104_mstest_10x5_210e_coco_20200824_185720-5fefbf1c.pth --work-dir tools/batch_test/cornernet_hourglass104_mstest_8x6_210e_coco --eval bbox --cfg-option dist_params.port=29673  &
+echo 'configs/dcn/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco configs/dcn/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco_20200130-d68aed1e.pth --work-dir tools/batch_test/faster_rcnn_r50_fpn_dconv_c3-c5_1x_coco --eval bbox --cfg-option dist_params.port=29674  &
+echo 'configs/deformable_detr/deformable_detr_r50_16x2_50e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION deformable_detr_r50_16x2_50e_coco configs/deformable_detr/deformable_detr_r50_16x2_50e_coco.py $CHECKPOINT_DIR/deformable_detr_r50_16x2_50e_coco_20210419_220030-a12b9512.pth --work-dir tools/batch_test/deformable_detr_r50_16x2_50e_coco --eval bbox --cfg-option dist_params.port=29675  &
+echo 'configs/detectors/detectors_htc_r50_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION detectors_htc_r50_1x_coco configs/detectors/detectors_htc_r50_1x_coco.py $CHECKPOINT_DIR/detectors_htc_r50_1x_coco-329b1453.pth --work-dir tools/batch_test/detectors_htc_r50_1x_coco --eval bbox segm --cfg-option dist_params.port=29676  &
+echo 'configs/detr/detr_r50_8x2_150e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION detr_r50_8x2_150e_coco configs/detr/detr_r50_8x2_150e_coco.py $CHECKPOINT_DIR/detr_r50_8x2_150e_coco_20201130_194835-2c4b8974.pth --work-dir tools/batch_test/detr_r50_8x2_150e_coco --eval bbox --cfg-option dist_params.port=29677  &
+echo 'configs/double_heads/dh_faster_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION dh_faster_rcnn_r50_fpn_1x_coco configs/double_heads/dh_faster_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/dh_faster_rcnn_r50_fpn_1x_coco_20200130-586b67df.pth --work-dir tools/batch_test/dh_faster_rcnn_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29678  &
+echo 'configs/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION dynamic_rcnn_r50_fpn_1x_coco configs/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/dynamic_rcnn_r50_fpn_1x-62a3f276.pth --work-dir tools/batch_test/dynamic_rcnn_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29679  &
+echo 'configs/empirical_attention/faster_rcnn_r50_fpn_attention_1111_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_r50_fpn_attention_1111_1x_coco configs/empirical_attention/faster_rcnn_r50_fpn_attention_1111_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_attention_1111_1x_coco_20200130-403cccba.pth --work-dir tools/batch_test/faster_rcnn_r50_fpn_attention_1111_1x_coco --eval bbox --cfg-option dist_params.port=29680  &
+echo 'configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_r50_fpn_1x_coco configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth --work-dir tools/batch_test/faster_rcnn_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29681  &
+echo 'configs/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco configs/fcos/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco.py $CHECKPOINT_DIR/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco-0a0d75a8.pth --work-dir tools/batch_test/fcos_center-normbbox-centeronreg-giou_r50_caffe_fpn_gn-head_1x_coco --eval bbox --cfg-option dist_params.port=29682  &
+echo 'configs/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fovea_align_r50_fpn_gn-head_4x4_2x_coco configs/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco.py $CHECKPOINT_DIR/fovea_align_r50_fpn_gn-head_4x4_2x_coco_20200203-8987880d.pth --work-dir tools/batch_test/fovea_align_r50_fpn_gn-head_4x4_2x_coco --eval bbox --cfg-option dist_params.port=29683  &
+echo 'configs/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION retinanet_free_anchor_r50_fpn_1x_coco configs/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco.py $CHECKPOINT_DIR/retinanet_free_anchor_r50_fpn_1x_coco_20200130-0f67375f.pth --work-dir tools/batch_test/retinanet_free_anchor_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29684  &
+echo 'configs/fsaf/fsaf_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION fsaf_r50_fpn_1x_coco configs/fsaf/fsaf_r50_fpn_1x_coco.py $CHECKPOINT_DIR/fsaf_r50_fpn_1x_coco-94ccc51f.pth --work-dir tools/batch_test/fsaf_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29685  &
+echo 'configs/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco configs/gcnet/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco.py $CHECKPOINT_DIR/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco_20200202-587b99aa.pth --work-dir tools/batch_test/mask_rcnn_r50_fpn_syncbn-backbone_r16_gcb_c3-c5_1x_coco --eval bbox segm --cfg-option dist_params.port=29686  &
+echo 'configs/gfl/gfl_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION gfl_r50_fpn_1x_coco configs/gfl/gfl_r50_fpn_1x_coco.py $CHECKPOINT_DIR/gfl_r50_fpn_1x_coco_20200629_121244-25944287.pth --work-dir tools/batch_test/gfl_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29687  &
+echo 'configs/gn/mask_rcnn_r50_fpn_gn-all_2x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION mask_rcnn_r50_fpn_gn-all_2x_coco configs/gn/mask_rcnn_r50_fpn_gn-all_2x_coco.py $CHECKPOINT_DIR/mask_rcnn_r50_fpn_gn-all_2x_coco_20200206-8eee02a6.pth --work-dir tools/batch_test/mask_rcnn_r50_fpn_gn-all_2x_coco --eval bbox segm --cfg-option dist_params.port=29688  &
+echo 'configs/gn+ws/faster_rcnn_r50_fpn_gn_ws-all_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_r50_fpn_gn_ws-all_1x_coco configs/gn+ws/faster_rcnn_r50_fpn_gn_ws-all_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_gn_ws-all_1x_coco_20200130-613d9fe2.pth --work-dir tools/batch_test/faster_rcnn_r50_fpn_gn_ws-all_1x_coco --eval bbox --cfg-option dist_params.port=29689  &
+echo 'configs/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION grid_rcnn_r50_fpn_gn-head_2x_coco configs/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco.py $CHECKPOINT_DIR/grid_rcnn_r50_fpn_gn-head_2x_coco_20200130-6cca8223.pth --work-dir tools/batch_test/grid_rcnn_r50_fpn_gn-head_2x_coco --eval bbox --cfg-option dist_params.port=29690  &
+echo 'configs/groie/faster_rcnn_r50_fpn_groie_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_r50_fpn_groie_1x_coco configs/groie/faster_rcnn_r50_fpn_groie_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_fpn_groie_1x_coco_20200604_211715-66ee9516.pth --work-dir tools/batch_test/faster_rcnn_r50_fpn_groie_1x_coco --eval bbox --cfg-option dist_params.port=29691  &
+echo 'configs/guided_anchoring/ga_retinanet_r50_caffe_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION ga_retinanet_r50_caffe_fpn_1x_coco configs/guided_anchoring/ga_retinanet_r50_caffe_fpn_1x_coco.py $CHECKPOINT_DIR/ga_retinanet_r50_caffe_fpn_1x_coco_20201020-39581c6f.pth --work-dir tools/batch_test/ga_retinanet_r50_caffe_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29692  &
+echo 'configs/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION ga_faster_r50_caffe_fpn_1x_coco configs/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco.py $CHECKPOINT_DIR/ga_faster_r50_caffe_fpn_1x_coco_20200702_000718-a11ccfe6.pth --work-dir tools/batch_test/ga_faster_r50_caffe_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29693  &
+echo 'configs/hrnet/faster_rcnn_hrnetv2p_w18_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_hrnetv2p_w18_1x_coco configs/hrnet/faster_rcnn_hrnetv2p_w18_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_hrnetv2p_w18_1x_coco_20200130-56651a6d.pth --work-dir tools/batch_test/faster_rcnn_hrnetv2p_w18_1x_coco --eval bbox --cfg-option dist_params.port=29694  &
+echo 'configs/htc/htc_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION htc_r50_fpn_1x_coco configs/htc/htc_r50_fpn_1x_coco.py $CHECKPOINT_DIR/htc_r50_fpn_1x_coco_20200317-7332cf16.pth --work-dir tools/batch_test/htc_r50_fpn_1x_coco --eval bbox segm --cfg-option dist_params.port=29695  &
+echo 'configs/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION libra_faster_rcnn_r50_fpn_1x_coco configs/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/libra_faster_rcnn_r50_fpn_1x_coco_20200130-3afee3a9.pth --work-dir tools/batch_test/libra_faster_rcnn_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29696  &
+echo 'configs/mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION mask_rcnn_r50_fpn_1x_coco configs/mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/mask_rcnn_r50_fpn_1x_coco_20200205-d4b0c5d6.pth --work-dir tools/batch_test/mask_rcnn_r50_fpn_1x_coco --eval bbox segm --cfg-option dist_params.port=29697  &
+echo 'configs/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION ms_rcnn_r50_caffe_fpn_1x_coco configs/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco.py $CHECKPOINT_DIR/ms_rcnn_r50_caffe_fpn_1x_coco_20200702_180848-61c9355e.pth --work-dir tools/batch_test/ms_rcnn_r50_caffe_fpn_1x_coco --eval bbox segm --cfg-option dist_params.port=29698  &
+echo 'configs/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco configs/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco.py $CHECKPOINT_DIR/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco_20200520-1bdba3ce.pth --work-dir tools/batch_test/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco --eval bbox --cfg-option dist_params.port=29699  &
+echo 'configs/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION retinanet_r50_nasfpn_crop640_50e_coco configs/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco.py $CHECKPOINT_DIR/retinanet_r50_nasfpn_crop640_50e_coco-0ad1f644.pth --work-dir tools/batch_test/retinanet_r50_nasfpn_crop640_50e_coco --eval bbox --cfg-option dist_params.port=29700  &
+echo 'configs/paa/paa_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION paa_r50_fpn_1x_coco configs/paa/paa_r50_fpn_1x_coco.py $CHECKPOINT_DIR/paa_r50_fpn_1x_coco_20200821-936edec3.pth --work-dir tools/batch_test/paa_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29701  &
+echo 'configs/pafpn/faster_rcnn_r50_pafpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_r50_pafpn_1x_coco configs/pafpn/faster_rcnn_r50_pafpn_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_r50_pafpn_1x_coco_bbox_mAP-0.375_20200503_105836-b7b4b9bd.pth --work-dir tools/batch_test/faster_rcnn_r50_pafpn_1x_coco --eval bbox --cfg-option dist_params.port=29702  &
+echo 'configs/pisa/pisa_faster_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION pisa_faster_rcnn_r50_fpn_1x_coco configs/pisa/pisa_faster_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/pisa_faster_rcnn_r50_fpn_1x_coco-dea93523.pth --work-dir tools/batch_test/pisa_faster_rcnn_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29703  &
+echo 'configs/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION point_rend_r50_caffe_fpn_mstrain_1x_coco configs/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco.py $CHECKPOINT_DIR/point_rend_r50_caffe_fpn_mstrain_1x_coco-1bcb5fb4.pth --work-dir tools/batch_test/point_rend_r50_caffe_fpn_mstrain_1x_coco --eval bbox segm --cfg-option dist_params.port=29704  &
+echo 'configs/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION mask_rcnn_regnetx-3.2GF_fpn_1x_coco configs/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco.py $CHECKPOINT_DIR/mask_rcnn_regnetx-3.2GF_fpn_1x_coco_20200520_163141-2a9d1814.pth --work-dir tools/batch_test/mask_rcnn_regnetx-3.2GF_fpn_1x_coco --eval bbox segm --cfg-option dist_params.port=29705  &
+echo 'configs/reppoints/reppoints_moment_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION reppoints_moment_r50_fpn_1x_coco configs/reppoints/reppoints_moment_r50_fpn_1x_coco.py $CHECKPOINT_DIR/reppoints_moment_r50_fpn_1x_coco_20200330-b73db8d1.pth --work-dir tools/batch_test/reppoints_moment_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29706  &
+echo 'configs/res2net/faster_rcnn_r2_101_fpn_2x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_r2_101_fpn_2x_coco configs/res2net/faster_rcnn_r2_101_fpn_2x_coco.py $CHECKPOINT_DIR/faster_rcnn_r2_101_fpn_2x_coco-175f1da6.pth --work-dir tools/batch_test/faster_rcnn_r2_101_fpn_2x_coco --eval bbox --cfg-option dist_params.port=29707  &
+echo 'configs/resnest/faster_rcnn_s50_fpn_syncbn-backbone+head_mstrain-range_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION faster_rcnn_s50_fpn_syncbn-backbone+head_mstrain-range_1x_coco configs/resnest/faster_rcnn_s50_fpn_syncbn-backbone+head_mstrain-range_1x_coco.py $CHECKPOINT_DIR/faster_rcnn_s50_fpn_syncbn-backbone+head_mstrain-range_1x_coco_20200926_125502-20289c16.pth --work-dir tools/batch_test/faster_rcnn_s50_fpn_syncbn-backbone+head_mstrain-range_1x_coco --eval bbox --cfg-option dist_params.port=29708  &
+echo 'configs/retinanet/retinanet_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION retinanet_r50_fpn_1x_coco configs/retinanet/retinanet_r50_fpn_1x_coco.py $CHECKPOINT_DIR/retinanet_r50_fpn_1x_coco_20200130-c2398f9e.pth --work-dir tools/batch_test/retinanet_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29709  &
+echo 'configs/rpn/rpn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION rpn_r50_fpn_1x_coco configs/rpn/rpn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth --work-dir tools/batch_test/rpn_r50_fpn_1x_coco --eval proposal_fast --cfg-option dist_params.port=29710  &
+echo 'configs/sabl/sabl_retinanet_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION sabl_retinanet_r50_fpn_1x_coco configs/sabl/sabl_retinanet_r50_fpn_1x_coco.py $CHECKPOINT_DIR/sabl_retinanet_r50_fpn_1x_coco-6c54fd4f.pth --work-dir tools/batch_test/sabl_retinanet_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29711  &
+echo 'configs/sabl/sabl_faster_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION sabl_faster_rcnn_r50_fpn_1x_coco configs/sabl/sabl_faster_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/sabl_faster_rcnn_r50_fpn_1x_coco-e867595b.pth --work-dir tools/batch_test/sabl_faster_rcnn_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29712  &
+echo 'configs/scnet/scnet_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION scnet_r50_fpn_1x_coco configs/scnet/scnet_r50_fpn_1x_coco.py $CHECKPOINT_DIR/scnet_r50_fpn_1x_coco-c3f09857.pth --work-dir tools/batch_test/scnet_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29713  &
+echo 'configs/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION sparse_rcnn_r50_fpn_1x_coco configs/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco.py $CHECKPOINT_DIR/sparse_rcnn_r50_fpn_1x_coco_20201222_214453-dc79b137.pth --work-dir tools/batch_test/sparse_rcnn_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29714  &
+echo 'configs/ssd/ssd300_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION ssd300_coco configs/ssd/ssd300_coco.py $CHECKPOINT_DIR/ssd300_coco_20200307-a92d2092.pth --work-dir tools/batch_test/ssd300_coco --eval bbox --cfg-option dist_params.port=29715  &
+echo 'configs/tridentnet/tridentnet_r50_caffe_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION tridentnet_r50_caffe_1x_coco configs/tridentnet/tridentnet_r50_caffe_1x_coco.py $CHECKPOINT_DIR/tridentnet_r50_caffe_1x_coco_20201230_141838-2ec0b530.pth --work-dir tools/batch_test/tridentnet_r50_caffe_1x_coco --eval bbox --cfg-option dist_params.port=29716  &
+echo 'configs/vfnet/vfnet_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION vfnet_r50_fpn_1x_coco configs/vfnet/vfnet_r50_fpn_1x_coco.py $CHECKPOINT_DIR/vfnet_r50_fpn_1x_coco_20201027-38db6f58.pth --work-dir tools/batch_test/vfnet_r50_fpn_1x_coco --eval bbox --cfg-option dist_params.port=29717  &
+echo 'configs/yolact/yolact_r50_1x8_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION yolact_r50_1x8_coco configs/yolact/yolact_r50_1x8_coco.py $CHECKPOINT_DIR/yolact_r50_1x8_coco_20200908-f38d58df.pth --work-dir tools/batch_test/yolact_r50_1x8_coco --eval bbox segm --cfg-option dist_params.port=29718  &
+echo 'configs/yolo/yolov3_d53_320_273e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION yolov3_d53_320_273e_coco configs/yolo/yolov3_d53_320_273e_coco.py $CHECKPOINT_DIR/yolov3_d53_320_273e_coco-421362b6.pth --work-dir tools/batch_test/yolov3_d53_320_273e_coco --eval bbox --cfg-option dist_params.port=29719  &
+echo 'configs/yolof/yolof_r50_c5_8x8_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION yolof_r50_c5_8x8_1x_coco configs/yolof/yolof_r50_c5_8x8_1x_coco.py $CHECKPOINT_DIR/yolof_r50_c5_8x8_1x_coco_20210425_024427-8e864411.pth --work-dir tools/batch_test/yolof_r50_c5_8x8_1x_coco --eval bbox --cfg-option dist_params.port=29720  &
+echo 'configs/centernet/centernet_resnet18_dcnv2_140e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 tools/slurm_test.sh $PARTITION centernet_resnet18_dcnv2_140e_coco configs/centernet/centernet_resnet18_dcnv2_140e_coco.py $CHECKPOINT_DIR/centernet_resnet18_dcnv2_140e_coco_20210520_101209-da388ba2.pth --work-dir tools/batch_test/centernet_resnet18_dcnv2_140e_coco --eval bbox --cfg-option dist_params.port=29721  &

openmmlab_test/mmdetection-speed_xinpian/.dev_scripts/train_benchmark.sh

+echo 'configs/atss/atss_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab atss_r50_fpn_1x_coco configs/atss/atss_r50_fpn_1x_coco.py ./tools/work_dir/atss_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/autoassign/autoassign_r50_fpn_8x2_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab autoassign_r50_fpn_8x2_1x_coco configs/autoassign/autoassign_r50_fpn_8x2_1x_coco.py ./tools/work_dir/autoassign_r50_fpn_8x2_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab cascade_mask_rcnn_r50_fpn_1x_coco configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py ./tools/work_dir/cascade_mask_rcnn_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab crpn_faster_rcnn_r50_caffe_fpn_1x_coco configs/cascade_rpn/crpn_faster_rcnn_r50_caffe_fpn_1x_coco.py ./tools/work_dir/crpn_faster_rcnn_r50_caffe_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/centernet/centernet_resnet18_dcnv2_140e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab centernet_resnet18_dcnv2_140e_coco configs/centernet/centernet_resnet18_dcnv2_140e_coco.py ./tools/work_dir/centernet_resnet18_dcnv2_140e_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco.py' &
+GPUS=16  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab centripetalnet_hourglass104_mstest_16x6_210e_coco configs/centripetalnet/centripetalnet_hourglass104_mstest_16x6_210e_coco.py ./tools/work_dir/centripetalnet_hourglass104_mstest_16x6_210e_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab cornernet_hourglass104_mstest_8x6_210e_coco configs/cornernet/cornernet_hourglass104_mstest_8x6_210e_coco.py ./tools/work_dir/cornernet_hourglass104_mstest_8x6_210e_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/detectors/detectors_htc_r50_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab detectors_htc_r50_1x_coco configs/detectors/detectors_htc_r50_1x_coco.py ./tools/work_dir/detectors_htc_r50_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/deformable_detr/deformable_detr_r50_16x2_50e_coco.py' &
+GPUS=16  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab deformable_detr_r50_16x2_50e_coco configs/deformable_detr/deformable_detr_r50_16x2_50e_coco.py ./tools/work_dir/deformable_detr_r50_16x2_50e_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/detr/detr_r50_8x2_150e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab detr_r50_8x2_150e_coco configs/detr/detr_r50_8x2_150e_coco.py ./tools/work_dir/detr_r50_8x2_150e_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/double_heads/dh_faster_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab dh_faster_rcnn_r50_fpn_1x_coco configs/double_heads/dh_faster_rcnn_r50_fpn_1x_coco.py ./tools/work_dir/dh_faster_rcnn_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab dynamic_rcnn_r50_fpn_1x_coco configs/dynamic_rcnn/dynamic_rcnn_r50_fpn_1x_coco.py ./tools/work_dir/dynamic_rcnn_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_fpn_1x_coco configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py ./tools/work_dir/faster_rcnn_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_caffe_dc5_mstrain_1x_coco configs/faster_rcnn/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco.py ./tools/work_dir/faster_rcnn_r50_caffe_dc5_mstrain_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_caffe_fpn_mstrain_1x_coco configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco.py ./tools/work_dir/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_caffe_fpn_1x_coco configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_1x_coco.py ./tools/work_dir/faster_rcnn_r50_caffe_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/faster_rcnn/faster_rcnn_r50_fpn_ohem_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_fpn_ohem_1x_coco configs/faster_rcnn/faster_rcnn_r50_fpn_ohem_1x_coco.py ./tools/work_dir/faster_rcnn_r50_fpn_ohem_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab fovea_align_r50_fpn_gn-head_4x4_2x_coco configs/foveabox/fovea_align_r50_fpn_gn-head_4x4_2x_coco.py ./tools/work_dir/fovea_align_r50_fpn_gn-head_4x4_2x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/fp16/mask_rcnn_r50_fpn_fp16_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_r50_fpn_fp16_1x_coco configs/fp16/mask_rcnn_r50_fpn_fp16_1x_coco.py ./tools/work_dir/mask_rcnn_r50_fpn_fp16_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/fp16/retinanet_r50_fpn_fp16_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab retinanet_r50_fpn_fp16_1x_coco configs/fp16/retinanet_r50_fpn_fp16_1x_coco.py ./tools/work_dir/retinanet_r50_fpn_fp16_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab retinanet_free_anchor_r50_fpn_1x_coco configs/free_anchor/retinanet_free_anchor_r50_fpn_1x_coco.py ./tools/work_dir/retinanet_free_anchor_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/fsaf/fsaf_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab fsaf_r50_fpn_1x_coco configs/fsaf/fsaf_r50_fpn_1x_coco.py ./tools/work_dir/fsaf_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/gfl/gfl_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab gfl_r50_fpn_1x_coco configs/gfl/gfl_r50_fpn_1x_coco.py ./tools/work_dir/gfl_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/ghm/retinanet_ghm_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab retinanet_ghm_r50_fpn_1x_coco configs/ghm/retinanet_ghm_r50_fpn_1x_coco.py ./tools/work_dir/retinanet_ghm_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab grid_rcnn_r50_fpn_gn-head_2x_coco configs/grid_rcnn/grid_rcnn_r50_fpn_gn-head_2x_coco.py ./tools/work_dir/grid_rcnn_r50_fpn_gn-head_2x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab ga_faster_r50_caffe_fpn_1x_coco configs/guided_anchoring/ga_faster_r50_caffe_fpn_1x_coco.py ./tools/work_dir/ga_faster_r50_caffe_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/htc/htc_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab htc_r50_fpn_1x_coco configs/htc/htc_r50_fpn_1x_coco.py ./tools/work_dir/htc_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/ld/ld_r18_gflv1_r101_fpn_coco_1x.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab ld_r18_gflv1_r101_fpn_coco_1x configs/ld/ld_r18_gflv1_r101_fpn_coco_1x.py ./tools/work_dir/ld_r18_gflv1_r101_fpn_coco_1x --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab libra_faster_rcnn_r50_fpn_1x_coco configs/libra_rcnn/libra_faster_rcnn_r50_fpn_1x_coco.py ./tools/work_dir/libra_faster_rcnn_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco.py ./tools/work_dir/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab ms_rcnn_r50_caffe_fpn_1x_coco configs/ms_rcnn/ms_rcnn_r50_caffe_fpn_1x_coco.py ./tools/work_dir/ms_rcnn_r50_caffe_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco.py' &
+GPUS=4  GPUS_PER_NODE=4  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco configs/nas_fcos/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco.py ./tools/work_dir/nas_fcos_nashead_r50_caffe_fpn_gn-head_4x4_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/paa/paa_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab paa_r50_fpn_1x_coco configs/paa/paa_r50_fpn_1x_coco.py ./tools/work_dir/paa_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/pisa/pisa_mask_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab pisa_mask_rcnn_r50_fpn_1x_coco configs/pisa/pisa_mask_rcnn_r50_fpn_1x_coco.py ./tools/work_dir/pisa_mask_rcnn_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab point_rend_r50_caffe_fpn_mstrain_1x_coco configs/point_rend/point_rend_r50_caffe_fpn_mstrain_1x_coco.py ./tools/work_dir/point_rend_r50_caffe_fpn_mstrain_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/reppoints/reppoints_moment_r50_fpn_gn-neck+head_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab reppoints_moment_r50_fpn_gn-neck+head_1x_coco configs/reppoints/reppoints_moment_r50_fpn_gn-neck+head_1x_coco.py ./tools/work_dir/reppoints_moment_r50_fpn_gn-neck+head_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/retinanet/retinanet_r50_caffe_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab retinanet_r50_caffe_fpn_1x_coco configs/retinanet/retinanet_r50_caffe_fpn_1x_coco.py ./tools/work_dir/retinanet_r50_caffe_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/rpn/rpn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab rpn_r50_fpn_1x_coco configs/rpn/rpn_r50_fpn_1x_coco.py ./tools/work_dir/rpn_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/sabl/sabl_retinanet_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab sabl_retinanet_r50_fpn_1x_coco configs/sabl/sabl_retinanet_r50_fpn_1x_coco.py ./tools/work_dir/sabl_retinanet_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/ssd/ssd300_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab ssd300_coco configs/ssd/ssd300_coco.py ./tools/work_dir/ssd300_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/tridentnet/tridentnet_r50_caffe_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab tridentnet_r50_caffe_1x_coco configs/tridentnet/tridentnet_r50_caffe_1x_coco.py ./tools/work_dir/tridentnet_r50_caffe_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/vfnet/vfnet_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab vfnet_r50_fpn_1x_coco configs/vfnet/vfnet_r50_fpn_1x_coco.py ./tools/work_dir/vfnet_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/yolact/yolact_r50_1x8_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab yolact_r50_1x8_coco configs/yolact/yolact_r50_1x8_coco.py ./tools/work_dir/yolact_r50_1x8_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/yolo/yolov3_d53_320_273e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab yolov3_d53_320_273e_coco configs/yolo/yolov3_d53_320_273e_coco.py ./tools/work_dir/yolov3_d53_320_273e_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab sparse_rcnn_r50_fpn_1x_coco configs/sparse_rcnn/sparse_rcnn_r50_fpn_1x_coco.py ./tools/work_dir/sparse_rcnn_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/scnet/scnet_r50_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab scnet_r50_fpn_1x_coco configs/scnet/scnet_r50_fpn_1x_coco.py ./tools/work_dir/scnet_r50_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/yolof/yolof_r50_c5_8x8_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab yolof_r50_c5_8x8_1x_coco configs/yolof/yolof_r50_c5_8x8_1x_coco.py ./tools/work_dir/yolof_r50_c5_8x8_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/carafe/mask_rcnn_r50_fpn_carafe_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_r50_fpn_carafe_1x_coco configs/carafe/mask_rcnn_r50_fpn_carafe_1x_coco.py ./tools/work_dir/mask_rcnn_r50_fpn_carafe_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/dcn/faster_rcnn_r50_fpn_mdpool_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_fpn_mdpool_1x_coco configs/dcn/faster_rcnn_r50_fpn_mdpool_1x_coco.py ./tools/work_dir/faster_rcnn_r50_fpn_mdpool_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/dcn/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco configs/dcn/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco.py ./tools/work_dir/mask_rcnn_r50_fpn_dconv_c3-c5_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/dcn/faster_rcnn_r50_fpn_dpool_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_fpn_dpool_1x_coco configs/dcn/faster_rcnn_r50_fpn_dpool_1x_coco.py ./tools/work_dir/faster_rcnn_r50_fpn_dpool_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco configs/dcn/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco.py ./tools/work_dir/mask_rcnn_r50_fpn_mdconv_c3-c5_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/empirical_attention/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco configs/empirical_attention/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco.py ./tools/work_dir/faster_rcnn_r50_fpn_attention_1111_dcn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/gcnet/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco configs/gcnet/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco.py ./tools/work_dir/mask_rcnn_r50_fpn_r4_gcb_c3-c5_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/gn/mask_rcnn_r50_fpn_gn-all_2x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_r50_fpn_gn-all_2x_coco configs/gn/mask_rcnn_r50_fpn_gn-all_2x_coco.py ./tools/work_dir/mask_rcnn_r50_fpn_gn-all_2x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/gn+ws/mask_rcnn_r50_fpn_gn_ws-all_2x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_r50_fpn_gn_ws-all_2x_coco configs/gn+ws/mask_rcnn_r50_fpn_gn_ws-all_2x_coco.py ./tools/work_dir/mask_rcnn_r50_fpn_gn_ws-all_2x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/hrnet/mask_rcnn_hrnetv2p_w18_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_hrnetv2p_w18_1x_coco configs/hrnet/mask_rcnn_hrnetv2p_w18_1x_coco.py ./tools/work_dir/mask_rcnn_hrnetv2p_w18_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/pafpn/faster_rcnn_r50_pafpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_pafpn_1x_coco configs/pafpn/faster_rcnn_r50_pafpn_1x_coco.py ./tools/work_dir/faster_rcnn_r50_pafpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab retinanet_r50_nasfpn_crop640_50e_coco configs/nas_fpn/retinanet_r50_nasfpn_crop640_50e_coco.py ./tools/work_dir/retinanet_r50_nasfpn_crop640_50e_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_regnetx-3.2GF_fpn_1x_coco configs/regnet/mask_rcnn_regnetx-3.2GF_fpn_1x_coco.py ./tools/work_dir/mask_rcnn_regnetx-3.2GF_fpn_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/resnest/mask_rcnn_s50_fpn_syncbn-backbone+head_mstrain_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab mask_rcnn_s50_fpn_syncbn-backbone+head_mstrain_1x_coco configs/resnest/mask_rcnn_s50_fpn_syncbn-backbone+head_mstrain_1x_coco.py ./tools/work_dir/mask_rcnn_s50_fpn_syncbn-backbone+head_mstrain_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/res2net/faster_rcnn_r2_101_fpn_2x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r2_101_fpn_2x_coco configs/res2net/faster_rcnn_r2_101_fpn_2x_coco.py ./tools/work_dir/faster_rcnn_r2_101_fpn_2x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &
+echo 'configs/groie/faster_rcnn_r50_fpn_groie_1x_coco.py' &
+GPUS=8  GPUS_PER_NODE=8  CPUS_PER_TASK=2 ./tools/slurm_train.sh openmmlab faster_rcnn_r50_fpn_groie_1x_coco configs/groie/faster_rcnn_r50_fpn_groie_1x_coco.py ./tools/work_dir/faster_rcnn_r50_fpn_groie_1x_coco --cfg-options checkpoint_config.max_keep_ckpts=1 >/dev/null &

openmmlab_test/mmdetection-speed_xinpian/.eggs/Cython-3.0.0a10-py3.6.egg/Cython/Build/BuildExecutable.py

+"""
+Compile a Python script into an executable that embeds CPython.
+Requires CPython to be built as a shared library ('libpythonX.Y').
+
+Basic usage:
+
+    python -m Cython.Build.BuildExecutable [ARGS] somefile.py
+"""
+
+from __future__ import absolute_import
+
+DEBUG = True
+
+import sys
+import os
+from distutils import sysconfig
+
+
+def get_config_var(name, default=''):
+    return sysconfig.get_config_var(name) or default
+
+INCDIR = sysconfig.get_python_inc()
+LIBDIR1 = get_config_var('LIBDIR')
+LIBDIR2 = get_config_var('LIBPL')
+PYLIB = get_config_var('LIBRARY')
+PYLIB_DYN = get_config_var('LDLIBRARY')
+if PYLIB_DYN == PYLIB:
+    # no shared library
+    PYLIB_DYN = ''
+else:
+    PYLIB_DYN = os.path.splitext(PYLIB_DYN[3:])[0]  # 'lib(XYZ).so' -> XYZ
+
+CC = get_config_var('CC', os.environ.get('CC', ''))
+CFLAGS = get_config_var('CFLAGS') + ' ' + os.environ.get('CFLAGS', '')
+LINKCC = get_config_var('LINKCC', os.environ.get('LINKCC', CC))
+LINKFORSHARED = get_config_var('LINKFORSHARED')
+LIBS = get_config_var('LIBS')
+SYSLIBS = get_config_var('SYSLIBS')
+EXE_EXT = sysconfig.get_config_var('EXE')
+
+
+def _debug(msg, *args):
+    if DEBUG:
+        if args:
+            msg = msg % args
+        sys.stderr.write(msg + '\n')
+
+
+def dump_config():
+    _debug('INCDIR: %s', INCDIR)
+    _debug('LIBDIR1: %s', LIBDIR1)
+    _debug('LIBDIR2: %s', LIBDIR2)
+    _debug('PYLIB: %s', PYLIB)
+    _debug('PYLIB_DYN: %s', PYLIB_DYN)
+    _debug('CC: %s', CC)
+    _debug('CFLAGS: %s', CFLAGS)
+    _debug('LINKCC: %s', LINKCC)
+    _debug('LINKFORSHARED: %s', LINKFORSHARED)
+    _debug('LIBS: %s', LIBS)
+    _debug('SYSLIBS: %s', SYSLIBS)
+    _debug('EXE_EXT: %s', EXE_EXT)
+
+
+def _parse_args(args):
+    cy_args = []
+    last_arg = None
+    for i, arg in enumerate(args):
+        if arg.startswith('-'):
+            cy_args.append(arg)
+        elif last_arg in ('-X', '--directive'):
+            cy_args.append(arg)
+        else:
+            input_file = arg
+            args = args[i+1:]
+            break
+        last_arg = arg
+    else:
+        raise ValueError('no input file provided')
+
+    return input_file, cy_args, args
+
+
+def runcmd(cmd, shell=True):
+    if shell:
+        cmd = ' '.join(cmd)
+        _debug(cmd)
+    else:
+        _debug(' '.join(cmd))
+
+    import subprocess
+    returncode = subprocess.call(cmd, shell=shell)
+
+    if returncode:
+        sys.exit(returncode)
+
+
+def clink(basename):
+    runcmd([LINKCC, '-o', basename + EXE_EXT, basename+'.o', '-L'+LIBDIR1, '-L'+LIBDIR2]
+           + [PYLIB_DYN and ('-l'+PYLIB_DYN) or os.path.join(LIBDIR1, PYLIB)]
+           + LIBS.split() + SYSLIBS.split() + LINKFORSHARED.split())
+
+
+def ccompile(basename):
+    runcmd([CC, '-c', '-o', basename+'.o', basename+'.c', '-I' + INCDIR] + CFLAGS.split())
+
+
+def cycompile(input_file, options=()):
+    from ..Compiler import Version, CmdLine, Main
+    options, sources = CmdLine.parse_command_line(list(options or ()) + ['--embed', input_file])
+    _debug('Using Cython %s to compile %s', Version.version, input_file)
+    result = Main.compile(sources, options)
+    if result.num_errors > 0:
+        sys.exit(1)
+
+
+def exec_file(program_name, args=()):
+    runcmd([os.path.abspath(program_name)] + list(args), shell=False)
+
+
+def build(input_file, compiler_args=(), force=False):
+    """
+    Build an executable program from a Cython module.
+
+    Returns the name of the executable file.
+    """
+    basename = os.path.splitext(input_file)[0]
+    exe_file = basename + EXE_EXT
+    if not force and os.path.abspath(exe_file) == os.path.abspath(input_file):
+        raise ValueError("Input and output file names are the same, refusing to overwrite")
+    if (not force and os.path.exists(exe_file) and os.path.exists(input_file)
+            and os.path.getmtime(input_file) <= os.path.getmtime(exe_file)):
+        _debug("File is up to date, not regenerating %s", exe_file)
+        return exe_file
+    cycompile(input_file, compiler_args)
+    ccompile(basename)
+    clink(basename)
+    return exe_file
+
+
+def build_and_run(args):
+    """
+    Build an executable program from a Cython module and run it.
+
+    Arguments after the module name will be passed verbatimly to the program.
+    """
+    program_name, args = _build(args)
+    exec_file(program_name, args)
+
+
+def _build(args):
+    input_file, cy_args, args = _parse_args(args)
+    program_name = build(input_file, cy_args)
+    return program_name, args
+
+
+if __name__ == '__main__':
+    _build(sys.argv[1:])