MMRotate

https://mmrotate.readthedocs.io/en/latest
Admin
MMRotate is an open-source rotation detection toolbox based on PyTorch, providing a comprehensive...
Tokens:16,967
Snippets:186
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install MMRotate from source

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Clones the repository and installs in editable mode for development purposes.

```bash
git clone https://github.com/open-mmlab/mmrotate.git
cd mmrotate
pip install -v -e .
```

--------------------------------

### Install MMRotate from Source on Google Colab

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Clones the repository and installs it in editable mode.

```bash
!git clone https://github.com/open-mmlab/mmrotate.git
%cd mmrotate
!pip install -e .
```

--------------------------------

### Install Dependencies on Google Colab

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Installs openmim, mmcv-full, and mmdet using MIM.

```bash
!pip3 install -U openmim
!mim install mmcv-full
!mim install mmdet
```

--------------------------------

### Install MMRotate via pip

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Installs MMRotate as a third-party package.

```bash
pip install mmrotate
```

--------------------------------

### Run Inference Demo from Source

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Executes the image inference script for installations performed from source.

```bash
python demo/image_demo.py demo/demo.jpg oriented_rcnn_r50_fpn_1x_dota_le90.py oriented_rcnn_r50_fpn_1x_dota_le90-6d2b2ce0.pth --out-file result.jpg
```

--------------------------------

### Install MMCV and MMDetection via MIM

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Installs the OpenMMLab package manager and required foundational libraries.

```bash
pip install -U openmim
mim install mmcv-full
mim install mmdet<3.0.0
```

--------------------------------

### Modify configuration via script arguments

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_config.html

Examples of using --cfg-options to override specific configuration parameters during training or testing.

```bash
--cfg-options model.backbone.norm_eval=False
```

```bash
--cfg-options data.train.pipeline.0.type=LoadImageFromWebcam
```

```bash
--cfg-options workflow="[(train,1),(val,1)]"
```

--------------------------------

### DOTA Annotation Format Example

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_dataset.html

Example of the 10-dimensional array structure used in DOTA format text files.

```text
184 2875 193 2923 146 2932 137 2885 plane 0
66 2095 75 2142 21 2154 11 2107 plane 0
...
```

--------------------------------

### RotatedRetinaNet Configuration Example

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_config.html

A comprehensive example of a RotatedRetinaNet configuration using ResNet50 and FPN, illustrating the structure of model components.

```python
angle_version = 'oc'  # The angle version
model = dict(
    type='RotatedRetinaNet',  # The name of detector
    backbone=dict(  # The config of backbone
        type='ResNet',  # The type of the backbone
        depth=50,  # The depth of backbone
        num_stages=4,  # Number of stages of the backbone.
        out_indices=(0, 1, 2, 3),  # The index of output feature maps produced in each stages
        frozen_stages=1,  # The weights in the first 1 stage are fronzen
        zero_init_residual=False,  # Whether to use zero init for last norm layer in resblocks to let them behave as identity.
        norm_cfg=dict(  # The config of normalization layers.
            type='BN',  # Type of norm layer, usually it is BN or GN
            requires_grad=True),  # Whether to train the gamma and beta in BN
        norm_eval=True,  # Whether to freeze the statistics in BN
        style='pytorch',  # The style of backbone, 'pytorch' means that stride 2 layers are in 3x3 conv, 'caffe' means stride 2 layers are in 1x1 convs.
        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),  # The ImageNet pretrained backbone to be loaded
    neck=dict(
        type='FPN',  # The neck of detector is FPN. We also support 'ReFPN'
        in_channels=[256, 512, 1024, 2048],  # The input channels, this is consistent with the output channels of backbone
        out_channels=256,  # The output channels of each level of the pyramid feature map
        start_level=1,  # Index of the start input backbone level used to build the feature pyramid
        add_extra_convs='on_input',  # It specifies the source feature map of the extra convs
        num_outs=5),  # The number of output scales
    bbox_head=dict(
        type='RotatedRetinaHead',# The type of bbox head is 'RRetinaHead'
        num_classes=15,  # Number of classes for classification
        in_channels=256,  # Input channels for bbox head
        stacked_convs=4,  # Number of stacking convs of the head
        feat_channels=256,  # Number of hidden channels
        assign_by_circumhbbox='oc',  # The angle version of obb2hbb
        anchor_generator=dict(  # The config of anchor generator
            type='RotatedAnchorGenerator',  # The type of anchor generator
            octave_base_scale=4,  # The base scale of octave.
            scales_per_octave=3,  #  Number of scales for each octave.
            ratios=[1.0, 0.5, 2.0],  # The ratio between height and width.
            strides=[8, 16, 32, 64, 128]),  # The strides of the anchor generator. This is consistent with the FPN feature strides.
        bbox_coder=dict(  # Config of box coder to encode and decode the boxes during training and testing
            type='DeltaXYWHAOBBoxCoder',  # Type of box coder.
            angle_range='oc',  # The angle version of box coder.
            norm_factor=None,  # The norm factor of box coder.
            edge_swap=False,  # The edge swap flag of box coder.
            proj_xy=False,  # The project flag of box coder.
            target_means=(0.0, 0.0, 0.0, 0.0, 0.0),  # The target means used to encode and decode boxes
            target_stds=(1.0, 1.0, 1.0, 1.0, 1.0)),  # The standard variance used to encode and decode boxes
        loss_cls=dict(  # Config of loss function for the classification branch
            type='FocalLoss',  # Type of loss for classification branch
```

--------------------------------

### Verify MMCV Installation

Source: https://mmrotate.readthedocs.io/en/latest/faq.html

Use this command to verify that MMCV and its operators are correctly installed and importable.

```bash
python -c 'import mmcv; import mmcv.ops'
```

--------------------------------

### Verify MMRotate Installation on Google Colab

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Checks the installed version of the mmrotate package.

```python
import mmrotate
print(mmrotate.__version__)
# Example output: 0.3.1
```

--------------------------------

### Install MMCV via Pip

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Installs mmcv-full manually by specifying the find-url based on PyTorch and CUDA versions.

```bash
pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu102/torch1.8/index.html
```

--------------------------------

### Install PyTorch dependencies

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Installs PyTorch 1.8.0 and torchvision 0.9.0 with CUDA 10.2 support.

```bash
conda install pytorch==1.8.0 torchvision==0.9.0 cudatoolkit=10.2 -c pytorch
```

--------------------------------

### Run Inference Demo via Python Interpreter

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Performs inference using the Python API for pip-based installations.

```python
from mmdet.apis import init_detector, inference_detector
import mmrotate

config_file = 'oriented_rcnn_r50_fpn_1x_dota_le90.py'
checkpoint_file = 'oriented_rcnn_r50_fpn_1x_dota_le90-6d2b2ce0.pth'
model = init_detector(config_file, checkpoint_file, device='cuda:0')
inference_detector(model, 'demo/demo.jpg')
```

--------------------------------

### Plot training curves with analyze_logs.py

Source: https://mmrotate.readthedocs.io/en/latest/useful_tools.html

Visualize loss or mAP metrics from training log files. Requires the seaborn library to be installed.

```bash
python tools/analysis_tools/analyze_logs.py plot_curve [--keys ${KEYS}] [--title ${TITLE}] [--legend ${LEGEND}] [--backend ${BACKEND}] [--style ${STYLE}] [--out ${OUT_FILE}]
```

```bash
python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls --legend loss_cls
```

```bash
python tools/analysis_tools/analyze_logs.py plot_curve log.json --keys loss_cls loss_bbox --out losses.pdf
```

```bash
python tools/analysis_tools/analyze_logs.py plot_curve log1.json log2.json --keys bbox_mAP --legend run1 run2
```

--------------------------------

### Print Full Configuration

Source: https://mmrotate.readthedocs.io/en/latest/useful_tools.html

Prints the entire configuration file verbatim, including all expanded imports.

```bash
python tools/misc/print_config.py ${CONFIG} [-h] [--options ${OPTIONS [OPTIONS...]}]
```

--------------------------------

### Download Config and Checkpoint Files

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Downloads the necessary configuration and checkpoint files for the inference demo.

```bash
mim download mmrotate --config oriented_rcnn_r50_fpn_1x_dota_le90 --dest .
```

--------------------------------

### Inspect configuration files

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_config.html

Use this command to view the fully resolved configuration file after inheritance and modular overrides.

```bash
python tools/misc/print_config.py /PATH/TO/CONFIG
```

--------------------------------

### Train with a single GPU

Source: https://mmrotate.readthedocs.io/en/latest/get_started.html

Execute training on a single GPU using the provided configuration file.

```bash
python tools/train.py ${CONFIG_FILE} [optional arguments]
```

--------------------------------

### Prepare Model for Publishing

Source: https://mmrotate.readthedocs.io/en/latest/useful_tools.html

Converts model weights to CPU tensors, removes optimizer states, and appends a hash ID to the filename for distribution.

```bash
python tools/model_converters/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
```

```bash
python tools/model_converters/publish_model.py work_dirs/rotated_faster_rcnn/latest.pth rotated_faster_rcnn_r50_fpn_1x_dota_le90_20190801.pth
```

--------------------------------

### Build and Run MMRotate Docker Image

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Commands to build the Docker image and run a container with GPU support.

```bash
# build an image with PyTorch 1.6, CUDA 10.1
# If you prefer other versions, just modified the Dockerfile
docker build -t mmrotate docker/
```

```bash
docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmrotate/data mmrotate
```

--------------------------------

### Create and activate a Conda environment

Source: https://mmrotate.readthedocs.io/en/latest/install.html

Initializes a new Python 3.8 environment named openmmlab.

```bash
conda create --name openmmlab python=3.8 -y
conda activate openmmlab
```

--------------------------------

### Configure Training Workflows

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Specify the sequence of training and validation phases using a list of tuples.

```python
workflow = [('train', 1)]
```

```python
[('train', 1), ('val', 1)]
```

--------------------------------

### Configuration File Naming Convention

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_config.html

The standard format for naming configuration files, where curly braces denote required fields and square brackets denote optional settings.

```text
{model}_[model setting]_{backbone}_{neck}_[norm setting]_[misc]_[gpu x batch_per_gpu]_{dataset}_{data setting}_{angle version}
```

--------------------------------

### Launch multiple jobs on a single machine

Source: https://mmrotate.readthedocs.io/en/latest/get_started.html

Run multiple training jobs on one machine by assigning unique ports to each process.

```bash
CUDA_VISIBLE_DEVICES=0,1,2,3 PORT=29500 ./tools/dist_train.sh ${CONFIG_FILE} 4
CUDA_VISIBLE_DEVICES=4,5,6,7 PORT=29501 ./tools/dist_train.sh ${CONFIG_FILE} 4
```

```python
dist_params = dict(backend='nccl', port=29500)
```

```python
dist_params = dict(backend='nccl', port=29501)
```

```bash
CUDA_VISIBLE_DEVICES=0,1,2,3 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config1.py ${WORK_DIR}
CUDA_VISIBLE_DEVICES=4,5,6,7 GPUS=4 ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} config2.py ${WORK_DIR}
```

--------------------------------

### Data Loader Configuration

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_config.html

Settings for batch size, worker threads, and dataset paths.

```python
data = dict(
    samples_per_gpu=2,  # Batch size of a single GPU
    workers_per_gpu=2,  # Worker to pre-fetch data for each single GPU
    train=dict(  # Train dataset config
        type='DOTADataset',  # Type of dataset
        ann_file=
        '../datasets/split_1024_dota1_0/trainval/annfiles/',  # Path of annotation file
        img_prefix=
        '../datasets/split_1024_dota1_0/trainval/images/',  # Prefix of image path
```

--------------------------------

### Generate Submission Files for DOTA-1.0

Source: https://mmrotate.readthedocs.io/en/latest/get_started.html

Commands to run inference and generate compressed files for online submission using RotatedRetinaNet.

```bash
python ./tools/test.py  \
  configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90.py \
  checkpoints/SOME_CHECKPOINT.pth --format-only \
  --eval-options submission_dir=work_dirs/Task1_results
```

```bash
./tools/dist_test.sh  \
  configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90.py \
  checkpoints/SOME_CHECKPOINT.pth 1 --format-only \
  --eval-options submission_dir=work_dirs/Task1_results
```

--------------------------------

### Convert MMRotate Models to TorchServe

Source: https://mmrotate.readthedocs.io/en/latest/useful_tools.html

Convert model files into a format compatible with TorchServe. The MODEL_STORE path must be an absolute path.

```bash
python tools/deployment/mmrotate2torchserve.py ${CONFIG_FILE} ${CHECKPOINT_FILE} \
--output-folder ${MODEL_STORE} \
--model-name ${MODEL_NAME}
```

```bash
wget -P checkpoint  \
https://download.openmmlab.com/mmrotate/v0.1.0/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90/rotated_faster_rcnn_r50_fpn_1x_dota_le90-0393aa5c.pth

python tools/deployment/mmrotate2torchserve.py configs/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90.py checkpoint/rotated_faster_rcnn_r50_fpn_1x_dota_le90-0393aa5c.pth \
--output-folder ${MODEL_STORE} \
--model-name rotated_faster_rcnn
```

--------------------------------

### Calculate Model FLOPs and Parameters

Source: https://mmrotate.readthedocs.io/en/latest/useful_tools.html

Use this script to estimate the computational complexity of a model based on a configuration file and optional input shape.

```bash
python tools/analysis_tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
```

--------------------------------

### Implement Custom Optimizer Constructor

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Create a custom constructor for fine-grained parameter tuning, such as layer-specific weight decay.

```python
from mmcv.utils import build_from_cfg

from mmcv.runner.optimizer import OPTIMIZER_BUILDERS, OPTIMIZERS
from mmrotate.utils import get_root_logger
from .my_optimizer import MyOptimizer


@OPTIMIZER_BUILDERS.register_module()
class MyOptimizerConstructor(object):

    def __init__(self, optimizer_cfg, paramwise_cfg=None):

    def __call__(self, model):

        return my_optimizer
```

--------------------------------

### Import new backbone module

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Register the new backbone by adding it to the package's __init__.py or using custom_imports in the configuration file.

```python
from .mobilenet import MobileNet
```

```python
custom_imports = dict(
    imports=['mmrotate.models.backbones.mobilenet'],
    allow_failed_imports=False)
```

--------------------------------

### Browse Datasets with browse_dataset.py

Source: https://mmrotate.readthedocs.io/en/latest/useful_tools.html

Use this script to visually inspect detection datasets or save images to a directory.

```bash
python tools/misc/browse_dataset.py ${CONFIG} [-h] [--skip-type ${SKIP_TYPE[SKIP_TYPE...]}] [--output-dir ${OUTPUT_DIR}] [--not-show] [--show-interval ${SHOW_INTERVAL}]
```

--------------------------------

### Benchmark Model FPS

Source: https://mmrotate.readthedocs.io/en/latest/useful_tools.html

Calculates model forward and post-processing speed. Requires single GPU distributed startup mode for accuracy.

```bash
python -m torch.distributed.launch --nproc_per_node=1 --master_port=${PORT} tools/analysis_tools/benchmark.py \
    ${CONFIG} \
    ${CHECKPOINT} \
    [--repeat-num ${REPEAT_NUM}] \
    [--max-iter ${MAX_ITER}] \
    [--log-interval ${LOG_INTERVAL}] \
    --launcher pytorch
```

```bash
python -m torch.distributed.launch --nproc_per_node=1 --master_port=29500 tools/analysis_tools/benchmark.py \
       configs/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90.py \
       checkpoints/rotated_faster_rcnn_r50_fpn_1x_dota_le90-0393aa5c.pth \
       --launcher pytorch
```

--------------------------------

### Train with multiple machines

Source: https://mmrotate.readthedocs.io/en/latest/get_started.html

Configure distributed training across multiple machines connected via ethernet.

```bash
NNODES=2 NODE_RANK=0 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
```

```bash
NNODES=2 NODE_RANK=1 PORT=$MASTER_PORT MASTER_ADDR=$MASTER_ADDR sh tools/dist_train.sh $CONFIG $GPUS
```

--------------------------------

### Run Model Inference Commands

Source: https://mmrotate.readthedocs.io/en/latest/get_started.html

General commands for testing models on single GPU, multi-GPU, or slurm-based multi-node environments.

```bash
# single-gpu
python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments]

# multi-gpu
./tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [optional arguments]

# multi-node in slurm environment
python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [optional arguments] --launcher slurm
```

--------------------------------

### Configure Learning Rate Schedules

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Define custom learning rate policies such as Poly or CosineAnnealing within the configuration dictionary.

```python
lr_config = dict(policy='poly', power=0.9, min_lr=1e-4, by_epoch=False)
```

```python
lr_config = dict(
    policy='CosineAnnealing',
    warmup='linear',
    warmup_iters=1000,
    warmup_ratio=1.0 / 10,
    min_lr_ratio=1e-5)
```

--------------------------------

### RotatedRetinaNet Configuration Parameters

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_config.html

Configuration settings for loss functions, training hyperparameters, and testing parameters for the RotatedRetinaNet model.

```python
            use_sigmoid=True,  #  Whether the prediction is used for sigmoid or softmax
            gamma=2.0,  # The gamma for calculating the modulating factor
            alpha=0.25,  # A balanced form for Focal Loss
            loss_weight=1.0),  # Loss weight of the classification branch
        loss_bbox=dict(  # Config of loss function for the regression branch
            type='L1Loss',  # Type of loss
            loss_weight=1.0)),  # Loss weight of the regression branch
    train_cfg=dict(  # Config of training hyperparameters
        assigner=dict(  # Config of assigner
            type='MaxIoUAssigner',  # Type of assigner
            pos_iou_thr=0.5,  # IoU >= threshold 0.5 will be taken as positive samples
            neg_iou_thr=0.4,  # IoU < threshold 0.4 will be taken as negative samples
            min_pos_iou=0,  # The minimal IoU threshold to take boxes as positive samples
            ignore_iof_thr=-1,  # IoF threshold for ignoring bboxes
            iou_calculator=dict(type='RBboxOverlaps2D')),  # Type of Calculator for IoU
        allowed_border=-1,  # The border allowed after padding for valid anchors.
        pos_weight=-1,  # The weight of positive samples during training.
        debug=False),  # Whether to set the debug mode
    test_cfg=dict(  # Config of testing hyperparameters
        nms_pre=2000,  # The number of boxes before NMS
        min_bbox_size=0,  # The allowed minimal box size
        score_thr=0.05,  # Threshold to filter out boxes
        nms=dict(iou_thr=0.1), # NMS threshold
        max_per_img=2000))  # The number of boxes to be kept after NMS.
```

--------------------------------

### Dataset and Normalization Configuration

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_config.html

Definitions for dataset type, root paths, and image normalization parameters.

```python
dataset_type = 'DOTADataset'  # Dataset type, this will be used to define the dataset
data_root = '../datasets/split_1024_dota1_0/'  # Root path of data
img_norm_cfg = dict(  # Image normalization config to normalize the input images
    mean=[123.675, 116.28, 103.53],  # Mean values used to pre-training the pre-trained backbone models
    std=[58.395, 57.12, 57.375],  # Standard variance used to pre-training the pre-trained backbone models
    to_rgb=True)  # The channel orders of image used to pre-training the pre-trained backbone models
```

--------------------------------

### Register the custom loss in __init__.py

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Expose the new loss class and function by adding them to the package's __init__.py file.

```python
from .my_loss import MyLoss, my_loss
```

--------------------------------

### Configure Momentum Scheduler

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Use cyclic momentum scheduling alongside learning rate scheduling to accelerate model convergence.

```python
lr_config = dict(
    policy='cyclic',
    target_ratio=(10, 1e-4),
    cyclic_times=1,
    step_ratio_up=0.4,
)
momentum_config = dict(
    policy='cyclic',
    target_ratio=(0.85 / 0.95, 1),
    cyclic_times=1,
    step_ratio_up=0.4,
)
```

--------------------------------

### Train with multiple GPUs

Source: https://mmrotate.readthedocs.io/en/latest/get_started.html

Use the distributed training script to train across multiple GPUs.

```bash
./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments]
```

--------------------------------

### Import new neck module

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Register the new neck by adding it to the package's __init__.py or using custom_imports in the configuration file.

```python
from .pafpn import PAFPN
```

```python
custom_imports = dict(
    imports=['mmrotate.models.necks.pafpn.py'],
    allow_failed_imports=False)
```

--------------------------------

### Register Custom Optimizer

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Expose the custom optimizer to the registry via package initialization or custom imports in the config.

```python
from .my_optimizer import MyOptimizer
```

```python
custom_imports = dict(imports=['mmrotate.core.optimizer.my_optimizer'], allow_failed_imports=False)
```

--------------------------------

### RotatedRetinaNet Configuration Parameters

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_config.html

Defines the training, validation, and testing pipelines, along with optimizer, learning rate, and runner configurations for RotatedRetinaNet.

```python
        pipeline=[  # pipeline, this is passed by the train_pipeline created before.
            dict(type='LoadImageFromFile'),
            dict(type='LoadAnnotations', with_bbox=True),
            dict(type='RResize', img_scale=(1024, 1024)),
            dict(type='RRandomFlip', flip_ratio=0.5, version='oc'),
            dict(
                type='Normalize',
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(type='Pad', size_divisor=32),
            dict(type='DefaultFormatBundle'),
            dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels'])
        ],
        version='oc'),
    val=dict(  # Validation dataset config
        type='DOTADataset',
        ann_file=
        '../datasets/split_1024_dota1_0/trainval/annfiles/',
        img_prefix=
        '../datasets/split_1024_dota1_0/trainval/images/',
        pipeline=[
            dict(type='LoadImageFromFile'),
            dict(
                type='MultiScaleFlipAug',
                img_scale=(1024, 1024),
                flip=False,
                transforms=[
                    dict(type='RResize'),
                    dict(
                        type='Normalize',
                        mean=[123.675, 116.28, 103.53],
                        std=[58.395, 57.12, 57.375],
                        to_rgb=True),
                    dict(type='Pad', size_divisor=32),
                    dict(type='DefaultFormatBundle'),
                    dict(type='Collect', keys=['img'])
                ])
        ],
        version='oc'),
    test=dict(  # Test dataset config, modify the ann_file for test-dev/test submission
        type='DOTADataset',
        ann_file=
        '../datasets/split_1024_dota1_0/test/images/',
        img_prefix=
        '../datasets/split_1024_dota1_0/test/images/',
        pipeline=[  # Pipeline is passed by test_pipeline created before
            dict(type='LoadImageFromFile'),
            dict(
                type='MultiScaleFlipAug',
                img_scale=(1024, 1024),
                flip=False,
                transforms=[
                    dict(type='RResize'),
                    dict(
                        type='Normalize',
                        mean=[123.675, 116.28, 103.53],
                        std=[58.395, 57.12, 57.375],
                        to_rgb=True),
                    dict(type='Pad', size_divisor=32),
                    dict(type='DefaultFormatBundle'),
                    dict(type='Collect', keys=['img'])
                ])
        ],
        version='oc'))
evaluation = dict(  # The config to build the evaluation hook
    interval=12,  # Evaluation interval
    metric='mAP')  # Metrics used during evaluation
optimizer = dict(  # Config used to build optimizer
    type='SGD',  # Type of optimizers
    lr=0.0025,  # Learning rate of optimizers
    momentum=0.9,  # Momentum
    weight_decay=0.0001)  # Weight decay of SGD
optimizer_config = dict(  # Config used to build the optimizer hook
    grad_clip=dict(
        max_norm=35,
        norm_type=2))
lr_config = dict(  # Learning rate scheduler config used to register LrUpdater hook
    policy='step',  # The policy of scheduler
    warmup='linear',  # The warmup policy, also support `exp` and `constant`.
    warmup_iters=500,  # The number of iterations for warmup
    warmup_ratio=0.3333333333333333,  # The ratio of the starting learning rate used for warmup
    step=[8, 11])  # Steps to decay the learning rate
runner = dict(
    type='EpochBasedRunner',  # Type of runner to use (i.e. IterBasedRunner or EpochBasedRunner)
    max_epochs=12) # Runner that runs the workflow in total max_epochs. For IterBasedRunner use `max_iters`
checkpoint_config = dict(  # Config to set the checkpoint hook
    interval=12)  # The save interval is 12
log_config = dict(  # config to register logger hook
    interval=50,  # Interval to print the log
    hooks=[
        # dict(type='TensorboardLoggerHook')  # The Tensorboard logger is also supported
        dict(type='TextLoggerHook')
    ])  # The logger used to record the training process.
dist_params = dict(backend='nccl')  # Parameters to setup distributed training, the port can also be set.
log_level = 'INFO'  # The level of logging.
load_from = None  # load models as a pre-trained model from a given path. This will not resume training.
resume_from = None  # Resume checkpoints from a given path, the training will be resumed from the epoch when the checkpoint's is saved.
workflow = [('train', 1)]  # Workflow for runner. [('train', 1)] means there is only one workflow and the workflow named 'train' is executed once. The workflow trains the model by 12 epochs according to the total_epochs.
work_dir = './work_dirs/rotated_retinanet_hbb_r50_fpn_1x_dota_oc'  # Directory to save the model checkpoints and logs for the current experiments.
```

--------------------------------

### Configure Data Loaders

Source: https://mmrotate.readthedocs.io/en/latest/changelog.html

Define data loader parameters including samples per GPU and worker counts for training, validation, and testing.

```python
data = dict(
    samples_per_gpu=2,  # only works for train_dataloader
    workers_per_gpu=2,  # only works for train_dataloader
    train=dict(type='xxx', ...),
    val=dict(type='xxx', ...),
    test=dict(type='xxx', ...),
    # Use different batch size during inference.
    val_dataloader=dict(samples_per_gpu=4, workers_per_gpu=4),
    test_dataloader=dict(samples_per_gpu=4, workers_per_gpu=4),
)
```

--------------------------------

### Configure backbone in config file

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Specify the custom backbone type and its arguments within the model configuration dictionary.

```python
model = dict(
    ...
    backbone=dict(
        type='MobileNet',
        arg1=xxx,
        arg2=xxx),
    ...
```

--------------------------------

### Manage jobs with Slurm

Source: https://mmrotate.readthedocs.io/en/latest/get_started.html

Submit training jobs to a cluster managed by Slurm.

```bash
[GPUS=${GPUS}] ./tools/slurm_train.sh ${PARTITION} ${JOB_NAME} ${CONFIG_FILE} ${WORK_DIR}
```

--------------------------------

### Test TorchServe Deployment

Source: https://mmrotate.readthedocs.io/en/latest/useful_tools.html

Verify the deployment using curl or the test_torchserver.py script to compare results.

```bash
curl -O https://raw.githubusercontent.com/open-mmlab/mmrotate/main/demo/demo.jpg
curl http://127.0.0.1:8080/predictions/${MODEL_NAME} -T demo.jpg
```

```json
[
  {
    "class_name": "small-vehicle",
    "bbox": [
      584.9473266601562,
      327.2749938964844,
      38.45665740966797,
      16.898427963256836,
      -0.7229751944541931
    ],
    "score": 0.9766026139259338
  },
  {
    "class_name": "small-vehicle",
    "bbox": [
      152.0239715576172,
      305.92572021484375,
      43.144744873046875,
      18.85024642944336,
      0.014928221702575684
    ],
    "score": 0.972826361656189
  },
  {
    "class_name": "large-vehicle",
    "bbox": [
      160.58056640625,
      437.3690185546875,
      55.6795654296875,
      19.31710433959961,
      0.007036328315734863
    ],
    "score": 0.888836681842804
  },
  {
    "class_name": "large-vehicle",
    "bbox": [
      666.2868041992188,
      1011.3961181640625,
      60.396209716796875,
      21.821645736694336,
      0.8549195528030396
    ],
    "score": 0.8240180015563965
  }
]
```

```bash
python tools/deployment/test_torchserver.py ${IMAGE_FILE} ${CONFIG_FILE} ${CHECKPOINT_FILE} ${MODEL_NAME}
[--inference-addr ${INFERENCE_ADDR}] [--device ${DEVICE}] [--score-thr ${SCORE_THR}]
```

```bash
python tools/deployment/test_torchserver.py \
demo/demo.jpg \
configs/rotated_faster_rcnn/rotated_faster_rcnn_r50_fpn_1x_dota_le90.py \
rotated_faster_rcnn_r50_fpn_1x_dota_le90-0393aa5c.pth \
rotated_fater_rcnn
```

--------------------------------

### Configure Gradient Clipping

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Enable gradient clipping in the optimizer_config to stabilize the training process.

```python
optimizer_config = dict(
    _delete_=True, grad_clip=dict(max_norm=35, norm_type=2))
```

--------------------------------

### Visualize Inference Results

Source: https://mmrotate.readthedocs.io/en/latest/get_started.html

Command to visualize model predictions and save them to a specified directory.

```bash
python ./tools/test.py \
  configs/rotated_retinanet/rotated_retinanet_obb_r50_fpn_1x_dota_le90.py \
  checkpoints/SOME_CHECKPOINT.pth \
  --show-dir work_dirs/vis
```

--------------------------------

### Define a new backbone

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Create a new backbone class by inheriting from nn.Module and registering it with the ROTATED_BACKBONES registry.

```python
import torch.nn as nn

from mmrotate.models.builder import ROTATED_BACKBONES


@ROTATED_BACKBONES.register_module()
class MobileNet(nn.Module):

    def __init__(self, arg1, arg2):
        pass

    def forward(self, x):  # should return a tuple
        pass
```

--------------------------------

### Register a new hook via package init

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Import the new hook module in the package's __init__.py file to ensure it is registered.

```python
from .my_hook import MyHook
```

--------------------------------

### Implement a Custom RoI Head

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Inherit from StandardRoIHead to implement custom RoI head logic.

```python
from mmrotate.models.builder import ROTATED_HEADS
from mmrotate.models.roi_heads.standard_roi_head import StandardRoIHead


@ROTATED_HEADS.register_module()
class DoubleHeadRoIHead(StandardRoIHead):
    """RoI head for Double Head RCNN

    https://arxiv.org/abs/1904.06493
    """

    def __init__(self, reg_roi_scale_factor, **kwargs):
        super(DoubleHeadRoIHead, self).__init__(**kwargs)
        self.reg_roi_scale_factor = reg_roi_scale_factor

    def _bbox_forward(self, x, rois):
        bbox_cls_feats = self.bbox_roi_extractor(
            x[:self.bbox_roi_extractor.num_inputs], rois)
        bbox_reg_feats = self.bbox_roi_extractor(
            x[:self.bbox_roi_extractor.num_inputs],
            rois,
            roi_scale_factor=self.reg_roi_scale_factor)
        if self.with_shared_head:
            bbox_cls_feats = self.shared_head(bbox_cls_feats)
            bbox_reg_feats = self.shared_head(bbox_reg_feats)
        cls_score, bbox_pred = self.bbox_head(bbox_cls_feats, bbox_reg_feats)

        bbox_results = dict(
            cls_score=cls_score,
            bbox_pred=bbox_pred,
            bbox_feats=bbox_cls_feats)
        return bbox_results
```

--------------------------------

### Calculate training speed

Source: https://mmrotate.readthedocs.io/en/latest/useful_tools.html

Compute average training time per iteration and epoch statistics from a log file.

```bash
python tools/analysis_tools/analyze_logs.py cal_train_time log.json [--include-outliers]
```

```text
-----Analyze train time of work_dirs/some_exp/20190611_192040.log.json-----
slowest epoch 11, average time is 1.2024
fastest epoch 1, average time is 1.1909
time std over epochs is 0.0028
average iter time: 1.1959 s/iter
```

--------------------------------

### Define MMRotate data configuration

Source: https://mmrotate.readthedocs.io/en/latest/changelog.html

Use this dictionary structure to define dataset paths and dataloader parameters for training, validation, and testing phases.

```python
data = dict(
    train=dict(type='xxx', ...),
    val=dict(type='xxx', ...),
    test=dict(type='xxx', ...),
    # Use different batch size during inference.
    train_dataloader=dict(samples_per_gpu=2, workers_per_gpu=2),
    val_dataloader=dict(samples_per_gpu=4, workers_per_gpu=4),
    test_dataloader=dict(samples_per_gpu=4, workers_per_gpu=4),
)
```

--------------------------------

### Register custom loss via config

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Alternatively, import the custom loss module directly within the configuration file.

```python
custom_imports=dict(
    imports=['mmrotate.models.losses.my_loss'])
```

--------------------------------

### Use existing MMCV hooks

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Directly reference pre-implemented MMCV hooks in the custom_hooks configuration list.

```python
custom_hooks = [dict(type='NumClassCheckHook')]
```

--------------------------------

### Configure neck in config file

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Update the neck configuration block to use the newly defined component.

```python
neck=dict(
    type='PAFPN',
    in_channels=[256, 512, 1024, 2048],
    out_channels=256,
    num_outs=5)
```

--------------------------------

### Update Dataloader Configuration

Source: https://mmrotate.readthedocs.io/en/latest/changelog.html

Comparison of dataloader configuration syntax between versions prior to 0.2.0 and version 0.3.0 onwards.

```python
data = dict(
    samples_per_gpu=2, workers_per_gpu=2,
    train=dict(type='xxx', ...),
    val=dict(type='xxx', samples_per_gpu=4, ...),
    test=dict(type='xxx', ...),
)
```

--------------------------------

### Training and Testing Data Pipelines

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_config.html

Data augmentation and processing pipelines for training and testing phases.

```python
train_pipeline = [  # Training pipeline
    dict(type='LoadImageFromFile'),  # First pipeline to load images from file path
    dict(type='LoadAnnotations',  # Second pipeline to load annotations for current image
         with_bbox=True),  # Whether to use bounding box, True for detection
    dict(type='RResize',  # Augmentation pipeline that resize the images and their annotations
         img_scale=(1024, 1024)),  # The largest scale of image
    dict(type='RRandomFlip',  # Augmentation pipeline that flip the images and their annotations
         flip_ratio=0.5,  # The ratio or probability to flip
         version='oc'),  # The angle version
    dict(
        type='Normalize',  # Augmentation pipeline that normalize the input images
        mean=[123.675, 116.28, 103.53],  # These keys are the same of img_norm_cfg since the
        std=[58.395, 57.12, 57.375],  # keys of img_norm_cfg are used here as arguments
        to_rgb=True),
    dict(type='Pad',  # Padding config
         size_divisor=32),  # The number the padded images should be divisible
    dict(type='DefaultFormatBundle'),  # Default format bundle to gather data in the pipeline
    dict(type='Collect',  # Pipeline that decides which keys in the data should be passed to the detector
         keys=['img', 'gt_bboxes', 'gt_labels'])
]
test_pipeline = [
    dict(type='LoadImageFromFile'),  # First pipeline to load images from file path
    dict(
        type='MultiScaleFlipAug',  # An encapsulation that encapsulates the testing augmentations
        img_scale=(1024, 1024),  # Decides the largest scale for testing, used for the Resize pipeline
        flip=False,  # Whether to flip images during testing
        transforms=[
            dict(type='RResize'),  # Use resize augmentation
            dict(
                type='Normalize',  # Normalization config, the values are from img_norm_cfg
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(type='Pad',  # Padding config to pad images divisible by 32.
                 size_divisor=32),
            dict(type='DefaultFormatBundle'),  # Default format bundle to gather data in the pipeline
            dict(type='Collect',  # Collect pipeline that collect necessary keys for testing.
                 keys=['img'])
        ])
]
```

--------------------------------

### Configure custom hooks in training

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Add the custom hook to the custom_hooks list in the configuration file, optionally specifying priority.

```python
custom_hooks = [
    dict(type='MyHook', a=a_value, b=b_value)
]
```

```python
custom_hooks = [
    dict(type='MyHook', a=a_value, b=b_value, priority='NORMAL')
]
```

--------------------------------

### Configure ClassBalancedDataset

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_dataset.html

Use ClassBalancedDataset to repeat a dataset based on category frequency, requiring the dataset to implement get_cat_ids(idx).

```python
dataset_A_train = dict(
        type='ClassBalancedDataset',
        oversample_thr=1e-3,
        dataset=dict(  # This is the original config of Dataset_A
            type='Dataset_A',
            ...
            pipeline=train_pipeline
        )
    )
```

--------------------------------

### Configure PyTorch Optimizer

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Modify the optimizer field in the configuration file to use standard PyTorch optimizers.

```python
optimizer = dict(type='Adam', lr=0.0003, weight_decay=0.0001)
```

--------------------------------

### StandardRoIHead Structure

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

The base class structure for RoI heads in MMRotate.

```python
import torch

from mmdet.core import bbox2result, bbox2roi, build_assigner, build_sampler
from mmrotate.models.builder import ROTATED_HEADS, build_head, build_roi_extractor
from mmrotate.models.roi_heads.base_roi_head import BaseRoIHead
from mmrotate.models.roi_heads.test_mixins import BBoxTestMixin, MaskTestMixin


@ROTATED_HEADS.register_module()
class StandardRoIHead(BaseRoIHead, BBoxTestMixin, MaskTestMixin):
    """Simplest base roi head including one bbox head and one mask head.
    """

    def init_assigner_sampler(self):

    def init_bbox_head(self, bbox_roi_extractor, bbox_head):

    def forward_dummy(self, x, proposals):


    def forward_train(self,
                      x,
                      img_metas,
                      proposal_list,
                      gt_bboxes,
                      gt_labels,
                      gt_bboxes_ignore=None,
                      gt_masks=None):

    def _bbox_forward(self, x, rois):

    def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
                            img_metas):

    def simple_test(self,
                    x,
                    proposal_list,
                    img_metas,
                    proposals=None,
                    rescale=False):
        """Test without augmentation."""
```

--------------------------------

### Register Custom Modules via Config

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Use custom_imports in the configuration file to register new modules without modifying init files.

```python
custom_imports=dict(
    imports=['mmrotate.models.roi_heads.double_roi_head', 'mmrotate.models.bbox_heads.double_bbox_head'])
```

--------------------------------

### Configure CheckpointHook

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Sets the interval for saving checkpoints using the checkpoint_config dictionary.

```python
checkpoint_config = dict(interval=1)
```

--------------------------------

### Implement a Custom BBox Head

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_models.html

Define a new bbox head by inheriting from BBoxHead and registering it with ROTATED_HEADS.

```python
from mmrotate.models.builder import ROTATED_HEADS
from mmrotate.models.roi_heads.bbox_heads.bbox_head import BBoxHead

@ROTATED_HEADS.register_module()
class DoubleConvFCBBoxHead(BBoxHead):
    r"""Bbox head used in Double-Head R-CNN

                                      /-> cls
                  /-> shared convs ->
                                      \-> reg
    roi features
                                      /-> cls
                  \-> shared fc    ->
                                      \-> reg
    """  # noqa: W605

    def __init__(self,
                 num_convs=0,
                 num_fcs=0,
                 conv_out_channels=1024,
                 fc_out_channels=1024,
                 conv_cfg=None,
                 norm_cfg=dict(type='BN'),
                 **kwargs):
        kwargs.setdefault('with_avg_pool', True)
        super(DoubleConvFCBBoxHead, self).__init__(**kwargs)


    def forward(self, x_cls, x_reg):


```

--------------------------------

### Define Custom Optimizer

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Implement a new optimizer by inheriting from torch.optim.Optimizer and registering it with OPTIMIZERS.

```python
from mmdet.core.optimizer.registry import OPTIMIZERS
from torch.optim import Optimizer


@OPTIMIZERS.register_module()
class MyOptimizer(Optimizer):

    def __init__(self, a, b, c)
```

--------------------------------

### Implement a new custom hook

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Define a new hook by inheriting from the MMCV Hook class and registering it with the HOOKS registry.

```python
from mmcv.runner import HOOKS, Hook


@HOOKS.register_module()
class MyHook(Hook):

    def __init__(self, a, b):
        pass

    def before_run(self, runner):
        pass

    def after_run(self, runner):
        pass

    def before_epoch(self, runner):
        pass

    def after_epoch(self, runner):
        pass

    def before_iter(self, runner):
        pass

    def after_iter(self, runner):
        pass
```

--------------------------------

### Configure Logger Hooks

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_runtime.html

Defines the logging interval and registers multiple logger hooks like TextLoggerHook and TensorboardLoggerHook.

```python
log_config = dict(
    interval=50,
    hooks=[
        dict(type='TextLoggerHook'),
        dict(type='TensorboardLoggerHook')
    ])
```

--------------------------------

### Configure RepeatDataset

Source: https://mmrotate.readthedocs.io/en/latest/tutorials/customize_dataset.html

Use RepeatDataset to repeat the entire dataset a specified number of times.

```python
dataset_A_train = dict(
        type='RepeatDataset',
        times=N,
        dataset=dict(  # This is the original config of Dataset_A
            type='Dataset_A',
            ...
            pipeline=train_pipeline
        )
    )
```
Tokens:
Raw