玩转MMDetection-MMDetection制作自己的配置文件（三）

玩转MMDetection-MMDetection中的模型框架文件及参数解读（一）

玩转MMDetection-MMDetection中的数据集文件、训练计划文件、运行信息文件及具体参数解读（二） 

1.导入模型架构、数据集文件、训练计划文件、运行信息文件

创建me.py文件，在_base_中引入自己所需的模型文件，数据集文件，训练计划文件，运行信息文件

本文用mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco.py作为例子讲解。

_base_ = [
    '../_base_/models/faster_rcnn_r50_fpn.py',#模型文件
    '../_base_/datasets/coco_detection.py',#数据集文件
    '../_base_/schedules/schedule_1x.py',#训练计划文件
    '../_base_/default_runtime.py' #运行信息文件
]

2.将模型框架文件中需要修改的参数，以固定的方式，在自己的配置文件中进行修改

之后在me.py中按照../_base_/models/faster_rcnn_r50_fpn.py文件，对应匹配写入你需要修改的一些参数，例如选用什么主干，主干通道数等。

model = dict(
	backbone=dict('各种你需要修改的参数，不需要修改的参数无需填写')，
	neck=dict('各种你需要修改的参数，不需要修改的参数无需填写')，
	rpn_head=dict('各种你需要修改的参数，不需要修改的参数无需填写'),
	roi_head=dict('各种你需要修改的参数，不需要修改的参数无需填写'),
	train_cfg=dict('各种你需要修改的参数，不需要修改的参数无需填写'),
	test_cfg=dict('各种你需要修改的参数，不需要修改的参数无需填写'),
)

重点强调，在你的me.py文件中，如果所有参数都与你所导入的../_base_/models/faster_rcnn_r50_fpn.py文件一致，则无需写入和更改。

 3.将数据集文件中需要修改的参数，以固定的方式，在自己的配置文件中进行修改

在完成第二步后的me.py文件中按照../_base_/datasets/coco_detection.py文件，对应匹配写入你需要修改的一些参数，例如更换什么图像预处理的方式，图像裁剪缩放大小等。

img_norm_cfg = dict(各种你需要修改的参数，不需要修改的参数无需填写),
train_pipeline =[
	dict(type='LoadImageFromFile'),
	dict(type='LoadAnnotations', with_bbox=True 修改的你需要的参数),
	dict(type='AutoAugment'
			policies=[
				[    dict(type='Rotate',
							level=5,
							img_fill_val=(124,116,104),
							prob=0.5,
							scale=1)
				],
				[   dict(type='Rotate',level=7,img_fill_val=(124,116,104)),
				        dict(type='Translate',
				        level=5,
				        prob=0.5,
				        img_fill_val=(124,116,104))
				],
				[    dict(type='Resize',
				               img_scale=[(),(),()],
				               multiscale_mode='value',
				               keep_ratio=True),
				],
				[    dict(type='Resize',
							img_scale=[(),(),()],
							multiscale_mode='value',
				            keep_ratio=True),
				     dict(type='RandomCrop',
				            crop_type='absolute_range',
				            crop_size=(),
				            allow_nagative_crop=True),
				    dict(type='Resize',
				           img_scale=[(),(),()], 
				           multiscale_mode='value',
				           override=True,
				           keep_ratio=True)
				]
			]),
	dict(type='normalize', ** img_norm_cfg),
	dict(type='Pad',size_divisor=32),
	dict(type='DefaultFormatBundle'),
	dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
]
test_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(
        type='MultiScaleFlipAug',
        img_scale=(1333, 800),
        flip=False,
        transforms=[
            dict(type='Resize', keep_ratio=True),
            dict(type='RandomFlip'),
            dict(type='Normalize', **img_norm_cfg),
            dict(type='Pad', size_divisor=32),
            dict(type='DefaultFormatBundle'),
            dict(type='Collect', keys=['img']),
        ])
]
data= dict(train=dict(pipeline=train_pipeline))

下图为对应的mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco.py文件中对应的数据集文件的配置

 4.将训练计划文件中需要修改的参数，以固定的方式，在自己的配置文件中进行修改

# optimizer
optimizer = dict(
    type='SGD',  # 可设为 'SGD', 'Adadelta', 'Adagrad', 'Adam', 'RMSprop' 等
    lr=0.02,
    momentum=0.9,
    weight_decay=0.0001)
optimizer_config = dict(grad_clip=None)
# learning policy
lr_config = dict(
    policy='step',  # 可设为 'step', 'cyclic', 'poly', 'ConsineAnnealing' 等
    warmup='linear',  # 可设为 'constant', 'linear', 'exp', 'None'
    warmup_iters=500,
    warmup_ratio=0.001,
    step=[80, 110, 160, 220, 240, 330])
runner = dict(type='EpochBasedRunner', max_epochs=360)#最大训练代数

下图为对应的mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco.py文件中对应的训练计划的文件配置

 5.将运行信息文件中需要修改的参数，以固定的方式，在自己的配置文件中进行修改

checkpoint_config = dict(interval=1)  # epoch
# yapf:disable
log_config = dict(
    interval=50,  # iteration
    hooks=[
        dict(type='TextLoggerHook'),
        # dict(type='TensorboardLoggerHook')
    ])
# yapf:enable
custom_hooks = [dict(type='NumClassCheckHook')]

dist_params = dict(backend='nccl')
log_level = 'INFO'
load_from = None #'/media/wkp/Data/zuoxinhao/Swin-Transformer-Object-Detection-master/mask_rcnn_swin_tiny_patch4_window7_1x.pth'
resume_from = None
workflow = [('train', 1)]  # 也可设为 [('train', 1), ('val', 1)]

下图为对应的mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco.py文件中对应的运行信息的文件配置

6.总结 

首先，创建属于自己的配置文件me.py；
其次，引入自己所需要的模型文件，数据集文件，训练计划文件，运行信息文件；
接着，从模型文件开始看，是否需要进行部分参数的更改，如果需要更改则按照引入的模型文件对应匹配写入me.py文件，且写入自己的参数；完成自己模型文件参数配置后，看数据集文件，是否需要进行部分参数的更改，如果需要更改则按照引入的数据集文件对应匹配写入me.py文件，且写入自己的参数；完成自己数据集参数配置后，看训练计划文件，是否需要进行部分参数的更改，如果需要更改则按照引入的训练计划文件对应匹配写入me.py文件，且写入自己的参数；完成自己训练计划参数配置后，看运行信息文件，是否需要进行部分参数的更改，如果需要更改则按照引入的运行信息文件对应匹配写入me.py文件，且写入自己的参数；
至此，属于自己的MMDetection的配置文件me.py即制作完成，之后就可以调用自己的me.py文件进行模型训练及测试。

以下为整个mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco.py的配置文件

_base_ = [
    '../_base_/models/mask_rcnn_swin_fpn.py',
    '../_base_/datasets/coco_detection.py',
    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
]

model = dict(
    backbone=dict(
        embed_dim=96,
        depths=[2, 2, 6, 2],
        num_heads=[3, 6, 12, 24],
        window_size=7,
        ape=False,
        drop_path_rate=0.1,
        patch_norm=True,
        use_checkpoint=False
    ),
    neck=dict(in_channels=[96, 192, 384, 768]))

img_norm_cfg = dict(
    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)

# augmentation strategy originates from DETR / Sparse RCNN
train_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(type='LoadAnnotations', with_bbox=True, with_mask=False),
    dict(type='RandomFlip', flip_ratio=0.5),
    dict(type='AutoAugment',
         policies=[
             [
                 dict(type='Resize',
                      img_scale=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
                                 (608, 1333), (640, 1333), (672, 1333), (704, 1333),
                                 (736, 1333), (768, 1333), (800, 1333)],
                      multiscale_mode='value',
                      keep_ratio=True)
             ],
             [
                 dict(type='Resize',
                      img_scale=[(400, 1333), (500, 1333), (600, 1333)],
                      multiscale_mode='value',
                      keep_ratio=True),
                 dict(type='RandomCrop',
                      crop_type='absolute_range',
                      crop_size=(384, 600),
                      allow_negative_crop=True),
                 dict(type='Resize',
                      img_scale=[(480, 1333), (512, 1333), (544, 1333),
                                 (576, 1333), (608, 1333), (640, 1333),
                                 (672, 1333), (704, 1333), (736, 1333),
                                 (768, 1333), (800, 1333)],
                      multiscale_mode='value',
                      override=True,
                      keep_ratio=True)
             ]
         ]),
    dict(type='Normalize', **img_norm_cfg),
    dict(type='Pad', size_divisor=32),
    dict(type='DefaultFormatBundle'),
    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
]
data = dict(train=dict(pipeline=train_pipeline))

optimizer = dict(_delete_=True, type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05,
                 paramwise_cfg=dict(custom_keys={'absolute_pos_embed': dict(decay_mult=0.),
                                                 'relative_position_bias_table': dict(decay_mult=0.),
                                                 'norm': dict(decay_mult=0.)}))
lr_config = dict(step=[8, 11])
runner = dict(type='EpochBasedRunnerAmp', max_epochs=12)

# do not use mmdet version fp16
fp16 = None
optimizer_config = dict(
    type="DistOptimizerHook",
    update_interval=1,
    grad_clip=None,
    coalesce=True,
    bucket_size_mb=-1,
    use_fp16=True,
)