MMYOLO and other OpenMMLab repositories use MMEngine's config system. It has a modular and inheritance design, which is convenient to conduct various experiments.
MMYOLO uses a modular design, all modules with different functions can be configured through the config. Taking YOLOv5-s as an example, we will introduce each field in the config according to different function modules:
When changing the training configuration, it is usually necessary to modify the following parameters. For example, the scaling factors deepen_factor and widen_factor are used by the network to control the size of the model in MMYOLO. So we recommend defining these parameters separately in the configuration file.
img_scale = (640, 640) # height of image, width of image
deepen_factor = 0.33 # The scaling factor that controls the depth of the network structure, 0.33 for YOLOv5-s
widen_factor = 0.5 # The scaling factor that controls the width of the network structure, 0.5 for YOLOv5-s
max_epochs = 300 # Maximum training epochs: 300 epochs
save_epoch_intervals = 10 # Validation intervals. Run validation every 10 epochs.
train_batch_size_pre_gpu = 16 # Batch size of a single GPU during training
train_num_workers = 8 # Worker to pre-fetch data for each single GPU
val_batch_size_pre_gpu = 1 # Batch size of a single GPU during validation.
val_num_workers = 2 # Worker to pre-fetch data for each single GPU during validationIn MMYOLO's config, we use model to set up detection algorithm components. In addition to neural network components such as backbone, neck, etc, it also requires data_preprocessor, train_cfg, and test_cfg. data_preprocessor is responsible for processing a batch of data output by the dataloader. train_cfg and test_cfg in the model config are for training and testing hyperparameters of the components.
anchors = [[(10, 13), (16, 30), (33, 23)], # Basic size of multi-scale prior box
[(30, 61), (62, 45), (59, 119)],
[(116, 90), (156, 198), (373, 326)]]
strides = [8, 16, 32] # Strides of multi-scale prior box
model = dict(
type='YOLODetector', # The name of detector
data_preprocessor=dict( # The config of data preprocessor, usually includes image normalization and padding
type='mmdet.DetDataPreprocessor', # The type of the data preprocessor, refer to https://mmdetection.readthedocs.io/en/dev-3.x/api.html#module-mmdet.models.data_preprocessors. It is worth noticing that using `YOLOv5DetDataPreprocessor` achieves faster training speed.
mean=[0., 0., 0.], # Mean values used to pre-training the pre-trained backbone models, ordered in R, G, B
std=[255., 255., 255.], # Standard variance used to pre-training the pre-trained backbone models, ordered in R, G, B
bgr_to_rgb=True), # whether to convert image from BGR to RGB
backbone=dict( # The config of backbone
type='YOLOv5CSPDarknet', # The type of backbone, currently it is available candidates are 'YOLOv5CSPDarknet', 'YOLOv6EfficientRep', 'YOLOXCSPDarknet'
deepen_factor=deepen_factor, # The scaling factor that controls the depth of the network structure
widen_factor=widen_factor, # The scaling factor that controls the width of the network structure
norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), # The config of normalization layers.
act_cfg=dict(type='SiLU', inplace=True)), # The config of activation function
neck=dict(
type='YOLOv5PAFPN', # The neck of detector is YOLOv5FPN, We also support 'YOLOv6RepPAFPN', 'YOLOXPAFPN'.
deepen_factor=deepen_factor, # The scaling factor that controls the depth of the network structure
widen_factor=widen_factor, # The scaling factor that controls the width of the network structure
in_channels=[256, 512, 1024], # The input channels, this is consistent with the output channels of backbone
out_channels=[256, 512, 1024], # The output channels of each level of the pyramid feature map, this is consistent with the input channels of head
num_csp_blocks=3, # The number of bottlenecks of CSPLayer
norm_cfg=dict(type='BN', momentum=0.03, eps=0.001), # The config of normalization layers.
act_cfg=dict(type='SiLU', inplace=True)), # The config of activation function
bbox_head=dict(
type='YOLOv5Head', # THe type of BBox head is 'YOLOv5Head', we also support 'YOLOv6Head', 'YOLOXHead'
head_module=dict(
type='YOLOv5HeadModule', # The type of Head module is 'YOLOv5HeadModule', we also support 'YOLOv6HeadModule', 'YOLOXHeadModule'
num_classes=80, # Number of classes for classification
in_channels=[256, 512, 1024], # The input channels, this is consistent with the input channels of neck
widen_factor=widen_factor, # The scaling factor that controls the width of the network structure
featmap_strides=[8, 16, 32], # The strides of the multi-scale feature maps
num_base_priors=3), # The number of prior boxes on a certain point
prior_generator=dict( # The config of prior generator
type='mmdet.YOLOAnchorGenerator', # The prior generator uses 'YOLOAnchorGenerator. Refer to https://github.com/open-mmlab/mmdetection/blob/dev-3.x/mmdet/models/task_modules/prior_generators/anchor_generator.py for more details
base_sizes=anchors, # Basic scale of the anchor
strides=strides), # The strides of the anchor generator. This is consistent with the FPN feature strides. The strides will be taken as base_sizes if base_sizes is not set.
),
test_cfg=dict(
multi_label=True, # The config of multi-label for multi-clas prediction. THe default setting is True.
nms_pre=30000, # The number of boxes before NMS
score_thr=0.001, # Threshold to filter out boxes.
nms=dict(type='nms', # Type of NMS
iou_threshold=0.65), # NMS threshold
max_per_img=300)) # Max number of detections of each imageDataloaders are required for the training, validation, and testing of the runner. Dataset and data pipeline need to be set to build the dataloader. Due to the complexity of this part, we use intermediate variables to simplify the writing of dataloader configs. More complex data augmentation methods are adopted for the lightweight object detection algorithms in MMYOLO. Therefore, MMYOLO has a wider range of dataset configurations than other models in MMDetection.
The training and testing data flow of YOLOv5 have a certain difference. We will introduce them separately here.
dataset_type = 'CocoDataset' # Dataset type, this will be used to define the dataset
data_root = 'data/coco/' # Root path of data
file_client_args = dict(backend='disk') # file client arguments, default backend loads from local disk
pre_transform = [ # Training data loading pipeline
dict(
type='LoadImageFromFile', # First pipeline to load images from file path
file_client_args=file_client_args), # file client arguments, default backend loads from local disk
dict(type='LoadAnnotations', # Second pipeline to load annotations for current image
with_bbox=True) # Whether to use bounding box, True for detection
]
albu_train_transforms = [ # Albumentation is introduced for image data augmentation. We follow the code of YOLOv5-v6.1, please make sure its version is 1.0.+
dict(type='Blur', p=0.01), # Blur augmentation, the probability is 0.01
dict(type='MedianBlur', p=0.01), # Median blue augmentation, the probability is 0.01
dict(type='ToGray', p=0.01), # Randomly convert RGB to gray-scale image, the probability is 0.01
dict(type='CLAHE', p=0.01) # CLAHE(Limited Contrast Adaptive Histogram Equalization) augmentation, the probability is 0.01
]
train_pipeline = [ # Training data processing pipeline
*pre_transform, # Introduce the pre-defined training data loading processing
dict(
type='Mosaic', # Mosaic augmentation
img_scale=img_scale, # The image scale after Mosaic augmentation
pad_val=114.0, # Pixel values filled with empty areas
pre_transform=pre_transform), # Pre-defined training data loading pipeline
dict(
type='YOLOv5RandomAffine', # Random Affine augmentation for YOLOv5
max_rotate_degree=0.0, # Maximum degrees of rotation transform
max_shear_degree=0.0, # Maximum degrees of shear transform
scaling_ratio_range=(0.5, 1.5), # Minimum and maximum ratio of scaling transform
border=(-img_scale[0] // 2, -img_scale[1] // 2), # Distance from height and width sides of input image to adjust output shape. Only used in mosaic dataset.
border_val=(114, 114, 114)), # Border padding values of 3 channels.
dict(
type='mmdet.Albu', # Albumentation of MMDetection
transforms=albu_train_transforms, # Pre-defined albu_train_transforms
bbox_params=dict(
type='BboxParams',
format='pascal_voc',
label_fields=['gt_bboxes_labels', 'gt_ignore_flags']),
keymap={
'img': 'image',
'gt_bboxes': 'bboxes'
}),
dict(type='YOLOv5HSVRandomAug'), # Random augmentation on HSV channel
dict(type='mmdet.RandomFlip', prob=0.5), # Random flip, the probability is 0.5
dict(
type='mmdet.PackDetInputs', # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples
meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip',
'flip_direction'))
]
train_dataloader = dict( # Train dataloader config
batch_size=train_batch_size_pre_gpu, # Batch size of a single GPU during training
num_workers=train_num_workers, # Worker to pre-fetch data for each single GPU during training
persistent_workers=True, # If ``True``, the dataloader will not shut down the worker processes after an epoch end, which can accelerate training speed.
pin_memory=True, # If ``True``, the dataloader will allow pinned memory, which can reduce copy time between CPU and memory
sampler=dict( # training data sampler
type='DefaultSampler', # DefaultSampler which supports both distributed and non-distributed training. Refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/dataset/sampler.py
shuffle=True), # randomly shuffle the training data in each epoch
dataset=dict( # Train dataset config
type=dataset_type,
data_root=data_root,
ann_file='annotations/instances_train2017.json', # Path of annotation file
data_prefix=dict(img='train2017/'), # Prefix of image path
filter_cfg=dict(filter_empty_gt=False, min_size=32), # Config of filtering images and annotations
pipeline=train_pipeline))In the testing phase of YOLOv5, the Letter Resize method resizes all the test images to the same scale, which preserves the aspect ratio of all testing images. Therefore, the validation and testing phases share the same data pipeline.
test_pipeline = [ # Validation/ Testing dataloader config
dict(
type='LoadImageFromFile', # First pipeline to load images from file path
file_client_args=file_client_args), # file client arguments, default backend loads from local disk
dict(type='YOLOv5KeepRatioResize', # Second pipeline to resize images with the same aspect ratio
scale=img_scale), # Pipeline that resizes the images
dict(
type='LetterResize', # Third pipeline to rescale images to meet the requirements of different strides
scale=img_scale, # Target scale of image
allow_scale_up=False, # Allow scale up when radio > 1
pad_val=dict(img=114)), # Padding value
dict(type='LoadAnnotations', with_bbox=True), # Forth pipeline to load annotations for current image
dict(
type='mmdet.PackDetInputs', # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples
meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
'scale_factor', 'pad_param'))
]
val_dataloader = dict(
batch_size=val_batch_size_pre_gpu, # Batch size of a single GPU
num_workers=val_num_workers, # Worker to pre-fetch data for each single GPU
persistent_workers=True, # If ``True``, the dataloader will not shut down the worker processes after an epoch end, which can accelerate training speed.
pin_memory=True, # If ``True``, the dataloader will allow pinned memory, which can reduce copy time between CPU and memory
drop_last=False, # IF ``True``, the dataloader will drop data, which fails to make a batch
sampler=dict(
type='DefaultSampler', # Default sampler for both distributed and normal training
shuffle=False), # not shuffle during validation and testing
dataset=dict(
type=dataset_type,
data_root=data_root,
test_mode=True, # # Turn on test mode of the dataset to avoid filtering annotations or images
data_prefix=dict(img='val2017/'), # Prefix of image path
ann_file='annotations/instances_val2017.json', # Path of annotation file
pipeline=test_pipeline,
batch_shapes_cfg=dict( # Config of batch shapes
type='BatchShapePolicy', # Policy that makes paddings with least pixels during batch inference process, which does not require the image scales of all batches to be the same throughout validation.
batch_size=val_batch_size_pre_gpu, # Batch size for batch shapes strategy, equals to validation batch size on single GPU
img_size=img_scale[0], # Image scale
size_divisor=32, # The image scale of padding should be divided by pad_size_divisor
extra_pad_ratio=0.5))) # additional paddings for pixel scale
test_dataloader = val_dataloaderEvaluators are used to compute the metrics of the trained model on the validation and testing datasets. The config of evaluators consists of one or a list of metric configs:
val_evaluator = dict( # Validation evaluator config
type='mmdet.CocoMetric', # The coco metric used to evaluate AR, AP, and mAP for detection
proposal_nums=(100, 1, 10), # The number of proposal used to evaluate for detection
ann_file=data_root + 'annotations/instances_val2017.json', # Annotation file path
metric='bbox', # Metrics to be evaluated, `bbox` for detection
)
test_evaluator = val_evaluator # Testing evaluator configSince the test dataset has no annotation files, the test_dataloader and test_evaluator config in MMYOLO are generally the same as the val's. If you want to save the detection results on the test dataset, you can write the config like this:
# inference on test dataset and
# format the output results for submission.
test_dataloader = dict(
batch_size=1,
num_workers=2,
persistent_workers=True,
drop_last=False,
sampler=dict(type='DefaultSampler', shuffle=False),
dataset=dict(
type=dataset_type,
data_root=data_root,
ann_file=data_root + 'annotations/image_info_test-dev2017.json',
data_prefix=dict(img='test2017/'),
test_mode=True,
pipeline=test_pipeline))
test_evaluator = dict(
type='mmdet.CocoMetric',
ann_file=data_root + 'annotations/image_info_test-dev2017.json',
metric='bbox',
format_only=True, # Only format and save the results to coco json file
outfile_prefix='./work_dirs/coco_detection/test') # The prefix of output json filesMMEngine's runner uses Loop to control the training, validation, and testing processes. Users can set the maximum training epochs and validation intervals with these fields.
max_epochs = 300 # Maximum training epochs: 300 epochs
save_epoch_intervals = 10 # Validation intervals. Run validation every 10 epochs.
train_cfg = dict(
type='EpochBasedTrainLoop', # The training loop type. Refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py
max_epochs=max_epochs, # Maximum training epochs: 300 epochs
val_interval=save_epoch_intervals) # Validation intervals. Run validation every 10 epochs.
val_cfg = dict(type='ValLoop') # The validation loop type
test_cfg = dict(type='TestLoop') # The testing loop typeMMEngine also supports dynamic intervals for evaluation. For example, you can run validation every 10 epochs on the first 280 epochs, and run validation every epoch on the final 20 epochs. The configurations are as follows.
max_epochs = 300 # Maximum training epochs: 300 epochs
save_epoch_intervals = 10 # Validation intervals. Run validation every 10 epochs.
train_cfg = dict(
type='EpochBasedTrainLoop', # The training loop type. Refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py
max_epochs=max_epochs, # Maximum training epochs: 300 epochs
val_interval=save_epoch_intervals, # Validation intervals. Run validation every 10 epochs.
dynamic_intervals=[(280, 1)]) # Switch evaluation on 280 epoch and switch the interval to 1.
val_cfg = dict(type='ValLoop') # The validation loop type
test_cfg = dict(type='TestLoop') # The testing loop typeoptim_wrapper is the field to configure optimization-related settings. The optimizer wrapper not only provides the functions of the optimizer, but also supports functions such as gradient clipping, mixed precision training, etc. Find out more in optimizer wrapper tutorial.
optim_wrapper = dict( # Optimizer wrapper config
type='OptimWrapper', # Optimizer wrapper type, switch to AmpOptimWrapper to enable mixed precision training.
optimizer=dict( # Optimizer config. Support all kinds of optimizers in PyTorch. Refer to https://pytorch.org/docs/stable/optim.html#algorithms
type='SGD', # Stochastic gradient descent optimizer
lr=0.01, # The base learning rate
momentum=0.937, # Stochastic gradient descent with momentum
weight_decay=0.0005, # Weight decay of SGD
nesterov=True, # Enable Nesterov momentum, Refer to http://www.cs.toronto.edu/~hinton/absps/momentum.pdf
batch_size_pre_gpu=train_batch_size_pre_gpu), # Enable automatic learning rate scaling
clip_grad=None, # Gradient clip option. Set None to disable gradient clip. Find usage in https://mmengine.readthedocs.io/en/latest/tutorials/optimizer.html
constructor='YOLOv5OptimizerConstructor') # The constructor for YOLOv5 optimizerparam_scheduler is the field that configures methods of adjusting optimization hyperparameters such as learning rate and momentum. Users can combine multiple schedulers to create a desired parameter adjustment strategy. Find more in parameter scheduler tutorial. In MMYOLO, no parameter optimizer is introduced.
param_scheduler = NoneUsers can attach hooks to training, validation, and testing loops to insert some operations during running. There are two different hook fields, one is default_hooks and the other is custom_hooks.
default_hooks is a dict of hook configs for the hooks that must be required at the runtime. They have default priority which should not be modified. If not set, runner will use the default values. To disable a default hook, users can set its config to None.
default_hooks = dict(
param_scheduler=dict(
type='YOLOv5ParamSchedulerHook', # MMYOLO uses `YOLOv5ParamSchedulerHook` to adjust hyper-parameters in optimizers
scheduler_type='linear',
lr_factor=0.01,
max_epochs=max_epochs),
checkpoint=dict(
type='CheckpointHook', # Hook to save model checkpoint on specific intervals
interval=save_epoch_intervals, # Save model checkpoint every 10 epochs.
max_keep_ckpts=3)) # The maximum checkpoints to keep.custom_hooks is a list of hook configs. Users can develop their own hooks and insert them in this field.
custom_hooks = [
dict(
type='EMAHook', # A Hook to apply Exponential Moving Average (EMA) on the model during training.
ema_type='ExpMomentumEMA', # The type of EMA strategy to use.
momentum=0.0001, # The momentum of EMA
update_buffers=True, # # If ``True``, calculate the running averages of model parameters
priority=49) # Priority higher than NORMAL(50)
]default_scope = 'mmyolo' # The default registry scope to find modules. Refer to https://mmengine.readthedocs.io/en/latest/tutorials/registry.html
env_cfg = dict(
cudnn_benchmark=True, # Whether to enable cudnn benchmark
mp_cfg=dict( # Multi-processing config
mp_start_method='fork', # Use fork to start multi-processing threads. 'fork' is usually faster than 'spawn' but may be unsafe. See discussion in https://github.com/pytorch/pytorch/issues/1355
opencv_num_threads=0), # Disable opencv multi-threads to avoid system being overloaded
dist_cfg=dict(backend='nccl'), # Distribution configs
)
vis_backends = [dict(type='LocalVisBackend')] # Visualization backends. Refer to: https://mmengine.readthedocs.io/zh_CN/latest/advanced_tutorials/visualization.html
visualizer = dict(
type='mmdet.DetLocalVisualizer', vis_backends=vis_backends, name='visualizer')
log_processor = dict(
type='LogProcessor', # Log processor to process runtime logs
window_size=50, # Smooth interval of log values
by_epoch=True) # Whether to format logs with epoch style. Should be consistent with the train loop's type.
log_level = 'INFO' # The level of logging.
load_from = None # Load model checkpoint as a pre-trained model from a given path. This will not resume training.
resume = False # Whether to resume from the checkpoint defined in `load_from`. If `load_from` is None, it will resume the latest checkpoint in the `work_dir`.config/_base_ contains default runtime. The configs that are composed of components from _base_ are called primitive.
For all configs under the same folder, it is recommended to have only one primitive config. All other configs should be inheritred from the primitive config. In this way, the maximum of inheritance level is 3.
For easy understanding, we recommend contributors inherit from existing methods.
For example, if some modification is made based on YOLOv5-s, such as modifying the depth of the network, users may first inherit the _base_ = ./yolov5_s-v61_syncbn_8xb16-300e_coco.py , then modify the necessary fields in the config files.
If you are building an entirely new method that does not share the structure with any of the existing methods, you may create a folder yolov100 under configs,
Please refer to mmengine config tutorial for more detailes.
By setting the _base_ field, we can set which files the current configuration file inherits from.
When _base_ is a string of a file path, it means inheriting the contents of one config file.
_base_ = '../_base_/default_runtime.py'When _base_ is a list of multiple file paths, it means inheriting multiple files.
_base_ = [
'./yolov5_s-v61_syncbn_8xb16-300e_coco.py',
'../_base_/default_runtime.py'
]If you wish to inspect the config file, you may run mim run mmdet print_config /PATH/TO/CONFIG to see the complete config.
Sometimes, you may set _delete_=True to ignore some of the fields in base configs.
You may refer to mmengine config tutorial for simple illustration.
In MMYOLO, for example, to change the backbone of YOLOv5 with the following config.
model = dict(
type='YOLODetector',
data_preprocessor=dict(...),
backbone=dict(
type='YOLOv5CSPDarknet',
deepen_factor=deepen_factor,
widen_factor=widen_factor,
norm_cfg=dict(type='BN', momentum=0.03, eps=0.001),
act_cfg=dict(type='SiLU', inplace=True)),
neck=dict(...),
bbox_head=dict(...))The _delete_=True would replace all old keys in backbone field with new keys. For example, YOLOv5 uses YOLOv5CSPDarknet, it is necessary to replace the backbone to YOLOv6EfficientRep. Since YOLOv5CSPDarknet and YOLOv6EfficientRep have different fields, you need to use _delete_=True to replace all old keys in the backbone field.
_base_ = '../yolov5/yolov5_s-v61_syncbn_8xb16-300e_coco.py'
model = dict(
backbone=dict(
_delete_=True,
type='YOLOv6EfficientRep',
deepen_factor=deepen_factor,
widen_factor=widen_factor,
norm_cfg=dict(type='BN', momentum=0.03, eps=0.001),
act_cfg=dict(type='ReLU', inplace=True)),
neck=dict(...),
bbox_head=dict(...))Some intermediate variables are used in the configs files, like train_pipeline and test_pipeline in datasets. It's worth noting that when modifying intermediate variables in the children configs, users need to pass the intermediate variables into corresponding fields again.
For example, we would like to change the image_scale during training and add YOLOv5MixUp data augmentation, img_scale/train_pipeline/test_pipeline are intermediate variable we would like modify.
Notice: YOLOv5MixUp requires adding the pre_transform and mosaic_affine_pipeline to its own pre_transform field. Please refer to The description of YOLOv5 algorithm and its implementation for detailed process and diagrams.
_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py'
img_scale = (1280, 1280) # image height, image width
affine_scale = 0.9
mosaic_affine_pipeline = [
dict(
type='Mosaic',
img_scale=img_scale,
pad_val=114.0,
pre_transform=pre_transform),
dict(
type='YOLOv5RandomAffine',
max_rotate_degree=0.0,
max_shear_degree=0.0,
scaling_ratio_range=(1 - affine_scale, 1 + affine_scale),
border=(-img_scale[0] // 2, -img_scale[1] // 2),
border_val=(114, 114, 114))
]
train_pipeline = [
*pre_transform, *mosaic_affine_pipeline,
dict(
type='YOLOv5MixUp', # MixUp augmentation of YOLOv5
prob=0.1, # the probability of YOLOv5MixUp
pre_transform=[*pre_transform,*mosaic_affine_pipeline]), # Pre-defined Training data pipeline and MixUp augmentation.
dict(
type='mmdet.Albu',
transforms=albu_train_transforms,
bbox_params=dict(
type='BboxParams',
format='pascal_voc',
label_fields=['gt_bboxes_labels', 'gt_ignore_flags']),
keymap={
'img': 'image',
'gt_bboxes': 'bboxes'
}),
dict(type='YOLOv5HSVRandomAug'),
dict(type='mmdet.RandomFlip', prob=0.5),
dict(
type='mmdet.PackDetInputs',
meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip',
'flip_direction'))
]
test_pipeline = [
dict(
type='LoadImageFromFile',
file_client_args={{_base_.file_client_args}}),
dict(type='YOLOv5KeepRatioResize', scale=img_scale),
dict(
type='LetterResize',
scale=img_scale,
allow_scale_up=False,
pad_val=dict(img=114)),
dict(type='LoadAnnotations', with_bbox=True),
dict(
type='mmdet.PackDetInputs',
meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
'scale_factor', 'pad_param'))
]
train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
test_dataloader = dict(dataset=dict(pipeline=test_pipeline))We first define new train_pipeline/test_pipeline and pass it into data.
Likewise, if we want to switch from SyncBN to BN or MMSyncBN, we need to modify every norm_cfg in the configuration file.
_base_ = './yolov5_s-v61_syncbn_8xb16-300e_coco.py'
norm_cfg = dict(type='BN', requires_grad=True)
model = dict(
backbone=dict(norm_cfg=norm_cfg),
neck=dict(norm_cfg=norm_cfg),
...)If the users want to reuse the variables in the base file, they can get a copy of the corresponding variable by using {{_base_.xxx}}. The latest version of MMEngine also support reusing variables without {{}} usage.
E.g:
_base_ = '../_base_/default_runtime.py'
file_client_args = {{_base_.file_client_args}} # `file_client_args` equals to `file_client_args` that defined in the _base_ config
pre_transform = _base_.pre_transform # `pre_transform` equals to `pre_transform` in the _base_ configWhen submitting jobs using tools/train.py or tools/test.py, you may specify --cfg-options to in-place modify the config.
-
Update config keys of dict chains.
The config options can be specified following the order of the dict keys in the original config. For example,
--cfg-options model.backbone.norm_eval=Falsechanges the all BN modules in model backbones totrainmode. -
Update keys inside a list of configs.
Some config dicts are composed as a list in your config. For example, the training pipeline
train_dataloader.dataset.pipelineis normally a list, e.g.[dict(type='LoadImageFromFile'), ...]. If you want to change'LoadImageFromFile'to'LoadImageFromNDArray'in the pipeline, you may specify--cfg-options data.train.pipeline.0.type=LoadImageFromNDArray. -
Update values of list/tuples.
Sometimes the value to update is a list or a tuple, for example, the config file normally sets
model.data_preprocessor.mean=[123.675, 116.28, 103.53]. If you want to change the mean values, you may specify--cfg-options model.data_preprocessor.mean="[127,127,127]". Note that the quotation mark"is necessary to support list/tuple data types, and that NO white space is allowed inside the quotation marks in the specified value.
We follow the below style to name config files. Contributors are advised to follow the same style.
{algorithm name}_{model component names [component1]_[component2]_[...]}-[version id]_[norm setting]_[data preprocessor type]_{training settings}_{training dataset information}_{testing dataset information}.py
The file name is divided into 8 name fields, which has 4 required parts and 4 optional parts. All parts and components are connected with _ and words of each part or component should be connected with -. {} indicates the required name field, [] indicates the optional name field.
{algorithm name}: The name of the algorithm. It can be a detector name such asyolov5,yolov6,yoloxetc.{component names}: Names of the components used in the algorithm such as backbone, neck, etc. For example,yolov5_smeans itsdeepen_factoris0.33and itswiden_factoris0.5.[version_id](optional): Since the evolution of YOLO series is much faster than traditional object detection algorithms,version idis used to distinguish the differences between different sub-versions. E.g, YOLOv5-3.0 uses theFocuslayer as the stem layer, and YOLOv5-6.0 uses theConvlayer as the stem layer.[norm_setting](optional):bnindicatesBatch Normalization,syncbnindicatesSynchronized Batch Normalization。[data preprocessor type](optional):fastincorporatesYOLOv5DetDataPreprocessorandyolov5_collateto preprocess data. The training speed is faster than defaultmmdet.DetDataPreprocessor, while results in extending tge overall pipeline to multi-task learning.{training settings}: Information of training settings such as batch size, augmentations, loss trick, scheduler, and epochs/iterations. For example:8xb16-300e_cocomeans using 8-gpus x 16-images-per-gpu, and train 300 epochs. Some abbreviations:{gpu x batch_per_gpu}: GPUs and samples per GPU.bNindicates N batch size per GPU. E.g.4xb4is the short term of 4-gpus x 4-images-per-gpu. And8xb2is used by default if not mentioned.{schedule}: training schedule, default option in MMYOLO is 300 epochs.
{training dataset information}: Training dataset names likecoco,cityscapes,voc-0712,wider-face,balloon.[testing dataset information](optional): Testing dataset name for models trained on one dataset but tested on another. If not mentioned, it means the model was trained and tested on the same dataset type.