Commit 608d4da1 authored by João Porto's avatar João Porto
Browse files

Update README.md

parents 7c5e17b3 a450ac2f

Too many changes to show.

To preserve performance only 1000 of 1000+ files are displayed.
# __compara_detectores_tf2
__autores__: Hemerson Pistori (pistori@ucdb.br)
__versao__: 1.0.0
# Compara Detectores MMDetection
- **autores**: Hemerson Pistori (pistori@ucdb.br), Fábio Prestes, João Vitor Porto (jvaporto@gmail.com)
- **versao**: 2.0.0
Scripts e patches para facilitar a utilização do mmdetection
Scripts e patches para facilitar a instalação e utilização do MMDetection.
Testado no Ubuntu 20.04 com python 3.7.7.
## Instalação e dependências:
Testado no Ubuntu 20.04 com python 3.7.7
Leia o arquivo install.sh para ver o que é preciso instalar
Leia o arquivo install.sh para ver os comandos necessários para instalar o projeto, ou crie o ambiente e instale todas as dependências usando o seguinte comando:
Placa gráfica: GTX 1070
```shell
sh install.sh
```
Caso o script em si não rode corretamente, rode cada linha de comando do script `install.sh` linha por linha.
Placa gráfica: GTX 1070
Driver nvidia: 450.66
## Preparação do mmdetection para novos dados
- Inicialmente o software está preparado para um problema de contagem de pupas de Spodoptera Frugiperda, um problema de duas (2) classes. Devido ao jeito que o MMDetection foi implementado, não é necessário uma classe para o fundo.
- Caso queira usar novos dados/datasets, sera necessário mudar certas variáveis em alguns arquivos espalhados pelo projeto.
- Para simplificar a utilização variada do MMDetection, todos os arquivos que devem ser mudados para novos datasets se encontram em utils/
- class_names.py
```python
# Modificar a função que contem o tipo de dataset sendo usado. Por exemplo, para datasets baseados no Coco/CocoDataset:
# Linha 67
def coco_classes():
return [
'Classe1', 'Classe2', [...], 'ClasseN'
]
```
- coco.py
```python
# Modificar o vetor de classes a ser usado no novo dataset
# Linha 22
CLASSES = ('Classe1', 'Classe2', 'Classe3', [...], 'ClasseN')
```
- coco_detection.py
```python
# Modificar o tipo de dataset, e os caminhos para as pastas de imagens e os arquivos de anotações.
# Exemplo: coco_detection.py, linha 32 para frente:
data = dict(
samples_per_gpu=2,
workers_per_gpu=2,
train=dict(
type=dataset_type,
classes=('Classe1', 'Classe2', 'Classe3', [...], 'ClasseN'), # As classes sendo usadas
ann_file=data_root + 'train/_annotations.coco.json', # Diretorio para o arquivo de anotacoes de treino
img_prefix=data_root + 'train/', # Diretorio para a pasta com todas as imagens de treino
pipeline=train_pipeline),
val=dict(
type=dataset_type,
classes=('Classe1', 'Classe2', 'Classe3', [...], 'ClasseN'), # As classes sendo usadas
ann_file=data_root + 'valid/_annotations.coco.json', # Diretorio para o arquivo de anotacoes de validacao
img_prefix=data_root + 'valid/', # Diretorio para a pasta com todas as imagens de validacao
pipeline=test_pipeline),
test=dict(
type=dataset_type,
classes=('Classe1', 'Classe2', 'Classe3', [...], 'ClasseN'), # As classes sendo usadas
ann_file=data_root + 'test/_annotations.coco.json', # Diretorio para o arquivo de anotacoes de teste
img_prefix=data_root + 'test/', # Diretorio para a pasta com todas as imagens de teste
pipeline=test_pipeline))
```
- Quaisquer arquivo de configuração de rede que sera usado, dependendo do arquivo.
É recomendado utilizar a [documentação do MMDetetion](https://mmdetection.readthedocs.io/en/latest/tutorials/config.html) para aprender exatamente o que cada arquivo base e variável modifica na rede. Em geral, a maioria das redes vão ser compostas de 4 componentes, mas podem ter menos ou nenhum componente base pronto:
- default_runtime.py
- schedule_1x.py/schedule_2x.py
- coco_detection.py
- Se usado, alguma rede base preparada previamente. Para saber quais redes já se tem prontas para usar como base, verifique `./mmdetection/configs/_base_/models/`
- Todos estes arquivos podem ser encontrados originalmente dentro de `./mmdetection/configs/_base_/`. Para simplificação de uso do projeto, estes arquivos tambem se encontram dentro da pasta `./utils`, e os arquivos localizados dentro desta pasta substituem os arquivos originais, entao caso modificações nestes arquivos sejam desejadas, modifique os arquivos dentro de `./utils/`.
## Usando outra arquitetura
<<<<<<< HEAD
## Preparação do mmdetection para novos dados
- Inicialmente o software está preparado para um problema de contagem de ovos do Aedes Aegypt. Um problema de uma classe (egg) além do fundo.
......@@ -62,6 +124,76 @@ Feche a janela da imagem para ver a próxima
`cd ../run`
`./detectaTodas.sh`
=======
- Troque o nome do arquivo de configuração da arquitetura (sem o .py) no arquivo `./run/arquitetura.txt`
- Opções disponíveis até agora para deteccao usando anotacoes tipo CocoJson, seguindo formatacao de dataset do [Roboflow](https://roboflow.com/):
- [x] faster_rcnn_r50_fpn_1x_voc0712
- [x] faster_rcnn_r101_fpn_1x_voc0712
- [x] retinanet_r50_fpn_1x_voc0712
- [x] retinanet_r101_fpn_1x_voc0712
- [x] fovea_r50_fpn_1x_voc0712
- [x] fovea_r101_fpn_1x_voc0712
- [x] sabl_faster_rcnn_r50_fpn_1x_voc0712
- [x] sabl_faster_rcnn_r101_fpn_1x_voc0712
- Para outras redes, verifique o [README.md original da MMDetection](mmdetection/README.md) para verificar todas as redes implementadas, caso nao queira rodar os scripts prontos acima.
## Exemplo de uso:
### Para utilizar datasets PASCAL VOC
1. Use o labelImg para anotar as imagens no formato pascalVOC
2. As imagens e os arquivos de anotação xml devem estar todos juntos em ./data/all/
3. Altere o arquivo ./utils/geraPascalVOC.sh se quiser usar um valor diferente de 0.8 (80%) para "treinamento+validação" (e portanto, 20% para teste)
4. Finalmente, seguir o [workflow basico a seguir](README.md#workflow-basico)
### Para utilizar datasets COCO
1. Use o [Roboflow](https://roboflow.com/) para anotar e dividir as imagens como desejar
2. Apos configurar o dataset, baixe-o no formato COCO
3. Pegue a pasta base criada, e insira em `./mmdetection/data/`
4. Modifique as pipelines de treino, validacao e teste para refletir o caminho para as imagens e anotacoes respectivas, como mostrado na seccao [Preparação do mmdetection para novos dados](README.md#preparação-do-mmdetection-para-novos-dados)
5. Finalmente, seguir o [workflow basico a seguir](README.md#workflow-basico)
### Workflow basico
6. Uma vez preparado o dataset, modificar `./run/arquitetura.txt` para o nome do arquivo de configuração desejada, retirando o `.py` do final
7. Para rodar o treinamento:
```shell
cd ../run
sh treina.sh
```
- Caso deseje rodar multiplas redes em paralelo (caso tenha acesso a multiplas GPUs), rode a primeira rede, modifique a variável gpu-ids a seguir para a outra GPU que deseje usar, modifique `./run/arquitetura.txt`, e rode a nova rede.
- Cuidado: Segundo alguns experimentos, certas redes não são capazes de rodar em paralelo com outras redes, dividindo poder de processamento, podendo acarretar a problemas como a perda (*loss*) alcancando NaN e nao treinando corretamente, entre outros problemas.
8. Para rodar o teste:
```shell
cd ../run
sh testa.py
```
- Por padrão, o script de teste irá inserir as imagens resultantes dentro da pasta `./results/`, em juncao a um arquivo pickle (.pkl) contendo todas as variáveis desejadas para análise estatistica do teste.
- Tambem se tem múltiplos scripts prontos para análise estatística dentro de [`./mmdetection/tools/analysis_tools`](mmdetection/tools/analysis_tools/)
- Para mais informações sobre estes scripts e como rodar cada um, por favor se refira a [documentacao do MMDetection sobre estes scripts](https://mmdetection.readthedocs.io/en/latest/useful_tools.html), suas explicações e seus exemplos de uso
- Atualmente, apenas a ferramenta de [analise de logs](mmdetection/tools/analysis_tools/analyze_logs.py) foi usada com sucesso
- Para instalar as dependências necessárias para este script, por favor instale as seguintes bibliotecas:
```shell
pip install numpy matplotlib seaborn
# Ou caso queira instalar em um ambiente separado do Anaconda:
conda install numpy matplotlib seaborn
```
## Funcoes possivelmente depreciadas
>>>>>>> pupae_experiment
### Detecta os objetos em uma imagem
- Possivelmente depreciado em v2.0
```shell
cd ../run
./detecta.sh caminho_para_arquivo_da_imagem
```
### Detecta os objetos em todas as imagens da pasta ./mmdetection/data/VOCdevkit/VOC2007/JPEGImages/
- Feche a janela da imagem para ver a próxima
- Possivelmente depreciado em v2.0
```shell
cd ../run
./detectaTodas.sh
```
......@@ -4,19 +4,13 @@
# Criando um ambiente conda específico para rodar o mmdetection
# estou usando esta versão do python pois não testei em outras
# (mas pode ser que funcione em outras)
conda create --name od python=3.7.7 -y
conda create --name openmmlab python=3.7 -y
# Ativando o ambiente recém criado (confira para ver se ativou
# corretamente olhando para a linha de comando, deve começar
# a aparecer um (od) no lugar de (base) no prompt
conda activate od
conda activate openmmlab
# Algumas coisas instalam com o conda mas outras precisam do pip
conda install pytorch torchvision -c pytorch
# Se der erro na linha abaixo pode ter relação com a instalação do CUDA
# e da placa gráfica na máquina
pip install mmcv-full
cd mmdetection
pip install -r requirements/build.txt
pip install -v -e . # or "python setup.py develop"
pip install seaborn
# openMim eh uma biblioteca do OpenMMLab para instalar todas a dependencias para seus projetos
pip install openmim
mim install mmdet
"""
some instructions
1. Fill the models that needs to be checked in the modelzoo_dict
2. Arange the structure of the directory as follows, the script will find the
corresponding config itself:
model_dir/model_family/checkpoints
e.g.: models/faster_rcnn/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth
models/faster_rcnn/faster_rcnn_r101_fpn_1x_coco_20200130-047c8118.pth
3. Excute the batch_test.sh
"""
import argparse
import json
import os
import subprocess
import mmcv
import torch
from mmcv import Config, get_logger
from mmcv.parallel import MMDataParallel, MMDistributedDataParallel
from mmcv.runner import (get_dist_info, init_dist, load_checkpoint,
wrap_fp16_model)
from mmdet.apis import multi_gpu_test, single_gpu_test
from mmdet.datasets import (build_dataloader, build_dataset,
replace_ImageToTensor)
from mmdet.models import build_detector
modelzoo_dict = {
'configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py': {
'bbox': 0.374
},
'configs/mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py': {
'bbox': 0.382,
'segm': 0.347
},
'configs/rpn/rpn_r50_fpn_1x_coco.py': {
'AR@1000': 0.582
}
}
def parse_args():
parser = argparse.ArgumentParser(
description='The script used for checking the correctness \
of batch inference')
parser.add_argument('model_dir', help='directory of models')
parser.add_argument(
'json_out', help='the output json records test information like mAP')
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 check_finish(all_model_dict, result_file):
# check if all models are checked
tested_cfgs = []
with open(result_file, 'r+') as f:
for line in f:
line = json.loads(line)
tested_cfgs.append(line['cfg'])
is_finish = True
for cfg in sorted(all_model_dict.keys()):
if cfg not in tested_cfgs:
return cfg
if is_finish:
with open(result_file, 'a+') as f:
f.write('finished\n')
def dump_dict(record_dict, json_out):
# dump result json dict
with open(json_out, 'a+') as f:
mmcv.dump(record_dict, f, file_format='json')
f.write('\n')
def main():
args = parse_args()
# touch the output json if not exist
with open(args.json_out, 'a+'):
pass
# init distributed env first, since logger depends on the dist
# info.
if args.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(args.launcher, backend='nccl')
rank, world_size = get_dist_info()
logger = get_logger('root')
# read info of checkpoints and config
result_dict = dict()
for model_family_dir in os.listdir(args.model_dir):
for model in os.listdir(
os.path.join(args.model_dir, model_family_dir)):
# cpt: rpn_r50_fpn_1x_coco_20200218-5525fa2e.pth
# cfg: rpn_r50_fpn_1x_coco.py
cfg = model.split('.')[0][:-18] + '.py'
cfg_path = os.path.join('configs', model_family_dir, cfg)
assert os.path.isfile(
cfg_path), f'{cfg_path} is not valid config path'
cpt_path = os.path.join(args.model_dir, model_family_dir, model)
result_dict[cfg_path] = cpt_path
assert cfg_path in modelzoo_dict, f'please fill the ' \
f'performance of cfg: {cfg_path}'
cfg = check_finish(result_dict, args.json_out)
cpt = result_dict[cfg]
try:
cfg_name = cfg
logger.info(f'evaluate {cfg}')
record = dict(cfg=cfg, cpt=cpt)
cfg = Config.fromfile(cfg)
# cfg.data.test.ann_file = 'data/val_0_10.json'
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.pretrained = None
if cfg.model.get('neck'):
if isinstance(cfg.model.neck, list):
for neck_cfg in cfg.model.neck:
if neck_cfg.get('rfp_backbone'):
if neck_cfg.rfp_backbone.get('pretrained'):
neck_cfg.rfp_backbone.pretrained = None
elif cfg.model.neck.get('rfp_backbone'):
if cfg.model.neck.rfp_backbone.get('pretrained'):
cfg.model.neck.rfp_backbone.pretrained = None
# in case the test dataset is concatenated
if isinstance(cfg.data.test, dict):
cfg.data.test.test_mode = True
elif isinstance(cfg.data.test, list):
for ds_cfg in cfg.data.test:
ds_cfg.test_mode = True
# build the dataloader
samples_per_gpu = 2 # hack test with 2 image per gpu
if samples_per_gpu > 1:
# Replace 'ImageToTensor' to 'DefaultFormatBundle'
cfg.data.test.pipeline = replace_ImageToTensor(
cfg.data.test.pipeline)
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(
dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# build the model and load checkpoint
model = build_detector(
cfg.model, train_cfg=None, test_cfg=cfg.test_cfg)
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
checkpoint = load_checkpoint(model, cpt, map_location='cpu')
# old versions did not save class info in checkpoints,
# this walkaround is for backward compatibility
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = dataset.CLASSES
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model, data_loader)
else:
model = MMDistributedDataParallel(
model.cuda(),
device_ids=[torch.cuda.current_device()],
broadcast_buffers=False)
outputs = multi_gpu_test(model, data_loader, 'tmp')
if rank == 0:
ref_mAP_dict = modelzoo_dict[cfg_name]
metrics = list(ref_mAP_dict.keys())
metrics = [
m if m != 'AR@1000' else 'proposal_fast' for m in metrics
]
eval_results = dataset.evaluate(outputs, metrics)
print(eval_results)
for metric in metrics:
if metric == 'proposal_fast':
ref_metric = modelzoo_dict[cfg_name]['AR@1000']
eval_metric = eval_results['AR@1000']
else:
ref_metric = modelzoo_dict[cfg_name][metric]
eval_metric = eval_results[f'{metric}_mAP']
if abs(ref_metric - eval_metric) > 0.003:
record['is_normal'] = False
dump_dict(record, args.json_out)
check_finish(result_dict, args.json_out)
except Exception as e:
logger.error(f'rank: {rank} test fail with error: {e}')
record['terminate'] = True
dump_dict(record, args.json_out)
check_finish(result_dict, args.json_out)
# hack there to throw some error to prevent hang out
subprocess.call('xxx')
if __name__ == '__main__':
main()
export PYTHONPATH=${PWD}
partition=$1
model_dir=$2
json_out=$3
job_name=batch_test
gpus=8
gpu_per_node=8
touch $json_out
lastLine=$(tail -n 1 $json_out)
while [ "$lastLine" != "finished" ]
do
srun -p ${partition} --gres=gpu:${gpu_per_node} -n${gpus} --ntasks-per-node=${gpu_per_node} \
--job-name=${job_name} --kill-on-bad-exit=1 \
python .dev_scripts/batch_test.py $model_dir $json_out --launcher='slurm'
lastLine=$(tail -n 1 $json_out)
echo $lastLine
done
# 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),