Initial test

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+inptest.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+**/*.jpg

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "yolov5"]
+	path = yolov5
+	url = https://github.com/ultralytics/yolov5

app.py

@@ -0,0 +1,51 @@
+from glob import glob
+from PIL import Image
+from ultralytics import YOLO
+from utils import draw_bbox
+import gradio as gr
+import numpy as np
+import subprocess
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("Detect planes demo.")
+
+    models=["SSD", "FasterRCNN", "CenterNet", "RetinaNet", "DETR", "RTMDET", "YOLOv5", "YOLOv8"] 
+
+    with gr.Tab("Image"):
+        with gr.Row():
+            with gr.Column():
+                image_input_single = gr.Image()
+            image_output = gr.Image(visible = True)
+        with gr.Row():
+            drop = gr.Dropdown([m for m in models], label="Model selection", type ="index", value=models[0])
+            image_button = gr.Button("Detect", variant = 'primary')
+            with gr.Column(visible=True) as output_row:
+                object_count = gr.Textbox(value = 0,label="Aircrafts detected")
+
+    def runmodel(input_img, model_num):
+        Image.fromarray(input_img).save(source:="inptest.jpg")
+        print("Using model", model_name:=models[model_num])
+
+        conf = 0.3
+
+        if model_name in models[:-2]:
+            cmd = f"python3 image_inference.py {source} inference/{model_name.lower()}_config.py --weights inference/models/{model_name.lower()}best.pth --out-dir inference/results/{model_name.lower()}_inference --pred-score-thr {conf}"
+            subprocess.run(cmd, shell=True)
+            im, count = draw_bbox(model_name.lower())
+
+        if model_name == "YOLOv5":
+            cmd = f"python3 yolov5/detect.py --weights inference/models/yolov5best.pt --source {source}  --save-txt --save-conf --project inference/results/yolov5_inference --name predict"
+            subprocess.run(cmd, shell=True)
+            im, count = draw_bbox(model_name.lower())
+
+        if model_name == "YOLOv8":
+            model = YOLO('inference/models/yolov8best.pt')
+            results = model(source, imgsz=1024, conf = conf, save_txt = True, save_conf = True, save = True, project = "inference/results/yolov8_inference")
+            im, count = draw_bbox(model_name.lower())
+
+        return im, count
+
+    image_button.click(runmodel, inputs=[image_input_single, drop], outputs=[image_output, object_count])
+
+demo.launch()

image_inference.py

@@ -0,0 +1,98 @@
+from argparse import ArgumentParser
+
+from mmengine.logging import print_log
+
+from mmdet.apis import DetInferencer
+
+
+def parse_args():
+    parser = ArgumentParser()
+    parser.add_argument(
+        'inputs', type=str, help='Input image file or folder path.')
+    parser.add_argument(
+        'model',
+        type=str,
+        help='Config or checkpoint .pth file or the model name '
+        'and alias defined in metafile. The model configuration '
+        'file will try to read from .pth if the parameter is '
+        'a .pth weights file.')
+    parser.add_argument('--weights', default=None, help='Checkpoint file')
+    parser.add_argument(
+        '--out-dir',
+        type=str,
+        default='outputs',
+        help='Output directory of images or prediction results.')
+    parser.add_argument('--texts', help='text prompt')
+    parser.add_argument(
+        '--device', default='cuda:0', help='Device used for inference')
+    parser.add_argument(
+        '--pred-score-thr',
+        type=float,
+        default=0.3,
+        help='bbox score threshold')
+    parser.add_argument(
+        '--batch-size', type=int, default=1, help='Inference batch size.')
+    parser.add_argument(
+        '--show',
+        action='store_true',
+        help='Display the image in a popup window.')
+    parser.add_argument(
+        '--no-save-vis',
+        action='store_true',
+        help='Do not save detection vis results')
+    parser.add_argument(
+        '--no-save-pred',
+        action='store_true',
+        help='Do not save detection json results')
+    parser.add_argument(
+        '--print-result',
+        action='store_true',
+        help='Whether to print the results.')
+    parser.add_argument(
+        '--palette',
+        default='none',
+        choices=['coco', 'voc', 'citys', 'random', 'none'],
+        help='Color palette used for visualization')
+    # only for GLIP
+    parser.add_argument(
+        '--custom-entities',
+        '-c',
+        action='store_true',
+        help='Whether to customize entity names? '
+        'If so, the input text should be '
+        '"cls_name1 . cls_name2 . cls_name3 ." format')
+
+    call_args = vars(parser.parse_args())
+
+    if call_args['no_save_vis'] and call_args['no_save_pred']:
+        call_args['out_dir'] = ''
+
+    if call_args['model'].endswith('.pth'):
+        print_log('The model is a weight file, automatically '
+                  'assign the model to --weights')
+        call_args['weights'] = call_args['model']
+        call_args['model'] = None
+
+    init_kws = ['model', 'weights', 'device', 'palette']
+    init_args = {}
+    for init_kw in init_kws:
+        init_args[init_kw] = call_args.pop(init_kw)
+
+    return init_args, call_args
+
+
+def main():
+    init_args, call_args = parse_args()
+    # TODO: Video and Webcam are currently not supported and
+    #  may consume too much memory if your input folder has a lot of images.
+    #  We will be optimized later.
+    inferencer = DetInferencer(**init_args)
+    inferencer(**call_args)
+
+    if call_args['out_dir'] != '' and not (call_args['no_save_vis']
+                                           and call_args['no_save_pred']):
+        print_log(f'Results have been saved at {call_args["out_dir"]}')
+
+
+if __name__ == '__main__':
+    main()

inference/centernet_config.py

@@ -0,0 +1,290 @@
+dataset_type = 'CocoDataset'
+data_root = '/home/safouane/Downloads/benchmark_aircraft/data/' # dataset root
+backend_args = None
+
+max_epochs = 500 
+
+metainfo = {
+    'classes': ('airplane', ),
+    'palette': [
+        (0, 128, 255),
+    ]
+}
+num_classes = 1        
+
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='RandomChoiceResize',
+        scales=[
+            ( 1333, 640, ),
+            ( 1333, 672, ),
+            ( 1333, 704, ),
+            ( 1333, 736, ),
+            ( 1333, 768, ),
+            ( 1333, 800, ),
+        ],
+        keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs'),
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='Resize', scale=(
+        1333,
+        800,
+    ), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=(
+            'img_id',
+            'img_path',
+            'ori_shape',
+            'img_shape',
+            'scale_factor',
+        )),
+]
+train_dataloader = dict(
+    batch_size=32,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    batch_sampler=dict(type='AspectRatioBatchSampler'),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=metainfo,
+        data_root=data_root,
+        ann_file='train/__coco.json',
+        data_prefix=dict(img='train/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='RandomChoiceResize',
+                scales=[
+                    ( 1333, 640, ),
+                    ( 1333, 672, ),
+                    ( 1333, 704, ),
+                    ( 1333, 736, ),
+                    ( 1333, 768, ),
+                    ( 1333, 800, ),
+                ],
+                keep_ratio=True),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PackDetInputs'),
+        ],
+        backend_args=None))
+val_dataloader = dict(
+    batch_size=32,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=metainfo,
+        data_root=data_root,
+        ann_file='val/__coco.json',
+        data_prefix=dict(img='val/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                1333,
+                800,
+            ), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+test_dataloader = dict(
+    batch_size=32,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=metainfo,
+        data_root=data_root,
+        ann_file='test/__coco.json',
+        data_prefix=dict(img='test/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                1333,
+                800,
+            ), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file=data_root + 'val/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+test_evaluator = dict(
+    type='CocoMetric',
+    ann_file=data_root + 'test/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=max_epochs, val_interval=10)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+param_scheduler = [
+    dict(
+        type='LinearLR',
+        start_factor=0.00025,
+        by_epoch=False,
+        begin=0,
+        end=4000),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=12,
+        by_epoch=True,
+        milestones=[
+            8,
+            11,
+        ],
+        gamma=0.1),
+]
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.015, momentum=0.9, weight_decay=0.0001),
+    paramwise_cfg=dict(norm_decay_mult=0.0))
+auto_scale_lr = dict(enable=False, base_batch_size=32)
+default_scope = 'mmdet'
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=5),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(
+        type='CheckpointHook',
+        interval=5,
+        max_keep_ckpts=2,  # only keep latest 2 checkpoints
+        save_best='auto'
+    ),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='DetVisualizationHook'))
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+vis_backends = [
+    dict(type='LocalVisBackend'),
+]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=[
+        dict(type='LocalVisBackend'),
+        dict(type='TensorboardVisBackend'),
+    ],
+    name='visualizer')
+
+log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True)
+log_level = 'INFO'
+load_from = None
+resume = False
+model = dict(
+    type='CenterNet',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[
+            103.53,
+            116.28,
+            123.675,
+        ],
+        std=[
+            1.0,
+            1.0,
+            1.0,
+        ],
+        bgr_to_rgb=False,
+        pad_size_divisor=32),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(
+            0,
+            1,
+            2,
+            3,
+        ),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=False),
+        norm_eval=True,
+        style='caffe',
+        init_cfg=dict(
+            type='Pretrained',
+            checkpoint='open-mmlab://detectron2/resnet50_caffe')),
+    neck=dict(
+        type='FPN',
+        in_channels=[
+            256,
+            512,
+            1024,
+            2048,
+        ],
+        out_channels=256,
+        start_level=1,
+        add_extra_convs='on_output',
+        num_outs=5,
+        init_cfg=dict(type='Caffe2Xavier', layer='Conv2d'),
+        relu_before_extra_convs=True),
+    bbox_head=dict(
+        type='CenterNetUpdateHead',
+        num_classes=num_classes,
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        strides=[
+            8,
+            16,
+            32,
+            64,
+            128,
+        ],
+        hm_min_radius=4,
+        hm_min_overlap=0.8,
+        more_pos_thresh=0.2,
+        more_pos_topk=9,
+        soft_weight_on_reg=False,
+        loss_cls=dict(
+            type='GaussianFocalLoss',
+            pos_weight=0.25,
+            neg_weight=0.75,
+            loss_weight=1.0),
+        loss_bbox=dict(type='GIoULoss', loss_weight=2.0)),
+    train_cfg=None,
+    test_cfg=dict(
+        nms_pre=1000,
+        min_bbox_size=0,
+        score_thr=0.05,
+        nms=dict(type='nms', iou_threshold=0.6),
+        max_per_img=100))

inference/detr_config.py

@@ -0,0 +1,542 @@
+dataset_type = 'CocoDataset'
+data_root = '/home/safouane/Downloads/benchmark_aircraft/data/'
+backend_args = None
+max_epochs = 500
+metainfo = {
+    'classes': ('airplane', ),
+    'palette': [
+        (0, 128, 255),
+    ]
+}
+num_classes = 1
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='RandomChoice',
+        transforms=[
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[
+                        (
+                            480,
+                            1333,
+                        ),
+                        (
+                            512,
+                            1333,
+                        ),
+                        (
+                            544,
+                            1333,
+                        ),
+                        (
+                            576,
+                            1333,
+                        ),
+                        (
+                            608,
+                            1333,
+                        ),
+                        (
+                            640,
+                            1333,
+                        ),
+                        (
+                            672,
+                            1333,
+                        ),
+                        (
+                            704,
+                            1333,
+                        ),
+                        (
+                            736,
+                            1333,
+                        ),
+                        (
+                            768,
+                            1333,
+                        ),
+                        (
+                            800,
+                            1333,
+                        ),
+                    ],
+                    keep_ratio=True),
+            ],
+            [
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[
+                        (
+                            400,
+                            1333,
+                        ),
+                        (
+                            500,
+                            1333,
+                        ),
+                        (
+                            600,
+                            1333,
+                        ),
+                    ],
+                    keep_ratio=True),
+                dict(
+                    type='RandomCrop',
+                    crop_type='absolute_range',
+                    crop_size=(
+                        384,
+                        600,
+                    ),
+                    allow_negative_crop=True),
+                dict(
+                    type='RandomChoiceResize',
+                    scales=[
+                        (
+                            480,
+                            1333,
+                        ),
+                        (
+                            512,
+                            1333,
+                        ),
+                        (
+                            544,
+                            1333,
+                        ),
+                        (
+                            576,
+                            1333,
+                        ),
+                        (
+                            608,
+                            1333,
+                        ),
+                        (
+                            640,
+                            1333,
+                        ),
+                        (
+                            672,
+                            1333,
+                        ),
+                        (
+                            704,
+                            1333,
+                        ),
+                        (
+                            736,
+                            1333,
+                        ),
+                        (
+                            768,
+                            1333,
+                        ),
+                        (
+                            800,
+                            1333,
+                        ),
+                    ],
+                    keep_ratio=True),
+            ],
+        ]),
+    dict(type='PackDetInputs'),
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='Resize', scale=(
+        1333,
+        800,
+    ), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=(
+            'img_id',
+            'img_path',
+            'ori_shape',
+            'img_shape',
+            'scale_factor',
+        )),
+]
+train_dataloader = dict(
+    batch_size=8,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    batch_sampler=dict(type='AspectRatioBatchSampler'),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='train/__coco.json',
+        data_prefix=dict(img='train/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(type='RandomFlip', prob=0.5),
+            dict(
+                type='RandomChoice',
+                transforms=[
+                    [
+                        dict(
+                            type='RandomChoiceResize',
+                            scales=[
+                                (
+                                    480,
+                                    1333,
+                                ),
+                                (
+                                    512,
+                                    1333,
+                                ),
+                                (
+                                    544,
+                                    1333,
+                                ),
+                                (
+                                    576,
+                                    1333,
+                                ),
+                                (
+                                    608,
+                                    1333,
+                                ),
+                                (
+                                    640,
+                                    1333,
+                                ),
+                                (
+                                    672,
+                                    1333,
+                                ),
+                                (
+                                    704,
+                                    1333,
+                                ),
+                                (
+                                    736,
+                                    1333,
+                                ),
+                                (
+                                    768,
+                                    1333,
+                                ),
+                                (
+                                    800,
+                                    1333,
+                                ),
+                            ],
+                            keep_ratio=True),
+                    ],
+                    [
+                        dict(
+                            type='RandomChoiceResize',
+                            scales=[
+                                (
+                                    400,
+                                    1333,
+                                ),
+                                (
+                                    500,
+                                    1333,
+                                ),
+                                (
+                                    600,
+                                    1333,
+                                ),
+                            ],
+                            keep_ratio=True),
+                        dict(
+                            type='RandomCrop',
+                            crop_type='absolute_range',
+                            crop_size=(
+                                384,
+                                600,
+                            ),
+                            allow_negative_crop=True),
+                        dict(
+                            type='RandomChoiceResize',
+                            scales=[
+                                (
+                                    480,
+                                    1333,
+                                ),
+                                (
+                                    512,
+                                    1333,
+                                ),
+                                (
+                                    544,
+                                    1333,
+                                ),
+                                (
+                                    576,
+                                    1333,
+                                ),
+                                (
+                                    608,
+                                    1333,
+                                ),
+                                (
+                                    640,
+                                    1333,
+                                ),
+                                (
+                                    672,
+                                    1333,
+                                ),
+                                (
+                                    704,
+                                    1333,
+                                ),
+                                (
+                                    736,
+                                    1333,
+                                ),
+                                (
+                                    768,
+                                    1333,
+                                ),
+                                (
+                                    800,
+                                    1333,
+                                ),
+                            ],
+                            keep_ratio=True),
+                    ],
+                ]),
+            dict(type='PackDetInputs'),
+        ],
+        backend_args=None))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='val/__coco.json',
+        data_prefix=dict(img='val/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                1333,
+                800,
+            ), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='test/__coco.json',
+        data_prefix=dict(img='test/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                1333,
+                800,
+            ), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file='/home/safouane/Downloads/benchmark_aircraft/data/val/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+test_evaluator = dict(
+    type='CocoMetric',
+    ann_file=
+    '/home/safouane/Downloads/benchmark_aircraft/data/test/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+default_scope = 'mmdet'
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=5),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', interval=5, save_best='auto'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='DetVisualizationHook'))
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+vis_backends = [
+    dict(type='LocalVisBackend'),
+]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=[
+        dict(type='LocalVisBackend'),
+        dict(type='TensorboardVisBackend'),
+    ],
+    name='visualizer')
+log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True)
+log_level = 'INFO'
+load_from = '/home/safouane/Downloads/benchmark_aircraft/mmdetection/configs/detr/checkpoints/detr_r50_8xb2-150e_coco_20221023_153551-436d03e8.pth'
+resume = False
+model = dict(
+    type='DETR',
+    num_queries=100,
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[
+            123.675,
+            116.28,
+            103.53,
+        ],
+        std=[
+            58.395,
+            57.12,
+            57.375,
+        ],
+        bgr_to_rgb=True,
+        pad_size_divisor=1),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(3, ),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=False),
+        norm_eval=True,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type='ChannelMapper',
+        in_channels=[
+            2048,
+        ],
+        kernel_size=1,
+        out_channels=256,
+        act_cfg=None,
+        norm_cfg=None,
+        num_outs=1),
+    encoder=dict(
+        num_layers=6,
+        layer_cfg=dict(
+            self_attn_cfg=dict(
+                embed_dims=256, num_heads=8, dropout=0.1, batch_first=True),
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,
+                num_fcs=2,
+                ffn_drop=0.1,
+                act_cfg=dict(type='ReLU', inplace=True)))),
+    decoder=dict(
+        num_layers=6,
+        layer_cfg=dict(
+            self_attn_cfg=dict(
+                embed_dims=256, num_heads=8, dropout=0.1, batch_first=True),
+            cross_attn_cfg=dict(
+                embed_dims=256, num_heads=8, dropout=0.1, batch_first=True),
+            ffn_cfg=dict(
+                embed_dims=256,
+                feedforward_channels=2048,
+                num_fcs=2,
+                ffn_drop=0.1,
+                act_cfg=dict(type='ReLU', inplace=True))),
+        return_intermediate=True),
+    positional_encoding=dict(num_feats=128, normalize=True),
+    bbox_head=dict(
+        type='DETRHead',
+        num_classes=1,
+        embed_dims=256,
+        loss_cls=dict(
+            type='CrossEntropyLoss',
+            bg_cls_weight=0.1,
+            use_sigmoid=False,
+            loss_weight=1.0,
+            class_weight=1.0),
+        loss_bbox=dict(type='L1Loss', loss_weight=5.0),
+        loss_iou=dict(type='GIoULoss', loss_weight=2.0)),
+    train_cfg=dict(
+        assigner=dict(
+            type='HungarianAssigner',
+            match_costs=[
+                dict(type='ClassificationCost', weight=1.0),
+                dict(type='BBoxL1Cost', weight=5.0, box_format='xywh'),
+                dict(type='IoUCost', iou_mode='giou', weight=2.0),
+            ])),
+    test_cfg=dict(max_per_img=100))
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.0001, weight_decay=0.0001),
+    clip_grad=dict(max_norm=0.1, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys=dict(backbone=dict(lr_mult=0.1, decay_mult=1.0))))
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=500, val_interval=1)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+param_scheduler = [
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=150,
+        by_epoch=True,
+        milestones=[
+            100,
+        ],
+        gamma=0.1),
+]
+auto_scale_lr = dict(base_batch_size=16)
+launcher = 'none'
+work_dir = './work_dirs/detr_r50_8xb2-150e_coco'

inference/fasterrcnn_config.py

@@ -0,0 +1,372 @@
+dataset_type = 'CocoDataset'
+data_root = '/home/safouane/Downloads/benchmark_aircraft/data/'
+backend_args = None
+max_epochs = 500
+metainfo = dict(
+    classes=('airplane', ), palette=[
+        (
+            0,
+            128,
+            255,
+        ),
+    ])
+num_classes = 1
+model = dict(
+    type='FasterRCNN',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[
+            103.53,
+            116.28,
+            123.675,
+        ],
+        std=[
+            1.0,
+            1.0,
+            1.0,
+        ],
+        bgr_to_rgb=False,
+        pad_size_divisor=32),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(
+            0,
+            1,
+            2,
+            3,
+        ),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=False),
+        norm_eval=True,
+        style='caffe',
+        init_cfg=dict(
+            type='Pretrained',
+            checkpoint='open-mmlab://detectron2/resnet50_caffe')),
+    neck=dict(
+        type='FPN',
+        in_channels=[
+            256,
+            512,
+            1024,
+            2048,
+        ],
+        out_channels=256,
+        num_outs=5),
+    rpn_head=dict(
+        type='RPNHead',
+        in_channels=256,
+        feat_channels=256,
+        anchor_generator=dict(
+            type='AnchorGenerator',
+            scales=[
+                8,
+            ],
+            ratios=[
+                0.5,
+                1.0,
+                2.0,
+            ],
+            strides=[
+                4,
+                8,
+                16,
+                32,
+                64,
+            ]),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+            ],
+            target_stds=[
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+            ]),
+        loss_cls=dict(
+            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
+        loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
+    roi_head=dict(
+        type='StandardRoIHead',
+        bbox_roi_extractor=dict(
+            type='SingleRoIExtractor',
+            roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
+            out_channels=256,
+            featmap_strides=[
+                4,
+                8,
+                16,
+                32,
+            ]),
+        bbox_head=dict(
+            type='Shared2FCBBoxHead',
+            in_channels=256,
+            fc_out_channels=1024,
+            roi_feat_size=7,
+            num_classes=1,
+            bbox_coder=dict(
+                type='DeltaXYWHBBoxCoder',
+                target_means=[
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                ],
+                target_stds=[
+                    0.1,
+                    0.1,
+                    0.2,
+                    0.2,
+                ]),
+            reg_class_agnostic=False,
+            loss_cls=dict(
+                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
+            loss_bbox=dict(type='L1Loss', loss_weight=1.0))),
+    train_cfg=dict(
+        rpn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.7,
+                neg_iou_thr=0.3,
+                min_pos_iou=0.3,
+                match_low_quality=True,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=256,
+                pos_fraction=0.5,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=False),
+            allowed_border=-1,
+            pos_weight=-1,
+            debug=False),
+        rpn_proposal=dict(
+            nms_pre=2000,
+            max_per_img=1000,
+            nms=dict(type='nms', iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            assigner=dict(
+                type='MaxIoUAssigner',
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.5,
+                min_pos_iou=0.5,
+                match_low_quality=False,
+                ignore_iof_thr=-1),
+            sampler=dict(
+                type='RandomSampler',
+                num=512,
+                pos_fraction=0.25,
+                neg_pos_ub=-1,
+                add_gt_as_proposals=True),
+            pos_weight=-1,
+            debug=False)),
+    test_cfg=dict(
+        rpn=dict(
+            nms_pre=1000,
+            max_per_img=1000,
+            nms=dict(type='nms', iou_threshold=0.7),
+            min_bbox_size=0),
+        rcnn=dict(
+            score_thr=0.05,
+            nms=dict(type='nms', iou_threshold=0.5),
+            max_per_img=100)))
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='Resize', scale=(
+        1333,
+        800,
+    ), keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs'),
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='Resize', scale=(
+        1333,
+        800,
+    ), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=(
+            'img_id',
+            'img_path',
+            'ori_shape',
+            'img_shape',
+            'scale_factor',
+        )),
+]
+train_dataloader = dict(
+    batch_size=32,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    batch_sampler=dict(type='AspectRatioBatchSampler'),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='train/__coco.json',
+        data_prefix=dict(img='train/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(type='Resize', scale=(
+                1333,
+                800,
+            ), keep_ratio=True),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PackDetInputs'),
+        ],
+        backend_args=None))
+val_dataloader = dict(
+    batch_size=32,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='val/__coco.json',
+        data_prefix=dict(img='val/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                1333,
+                800,
+            ), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+test_dataloader = dict(
+    batch_size=32,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='test/__coco.json',
+        data_prefix=dict(img='test/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                1333,
+                800,
+            ), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file='/home/safouane/Downloads/benchmark_aircraft/data/val/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+test_evaluator = dict(
+    type='CocoMetric',
+    ann_file=
+    '/home/safouane/Downloads/benchmark_aircraft/data/test/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=500, val_interval=1)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=12,
+        by_epoch=True,
+        milestones=[
+            8,
+            11,
+        ],
+        gamma=0.1),
+]
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.015, momentum=0.9, weight_decay=0.0001))
+auto_scale_lr = dict(enable=False, base_batch_size=32)
+default_scope = 'mmdet'
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', interval=50, save_best='auto'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='DetVisualizationHook'))
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+vis_backends = [
+    dict(type='LocalVisBackend'),
+]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=[
+        dict(type='LocalVisBackend'),
+        dict(type='TensorboardVisBackend'),
+    ],
+    name='visualizer')
+log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True)
+log_level = 'INFO'
+load_from = '/home/safouane/Downloads/benchmark_aircraft/mmlab_configs/faster_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.378_20200504_180032-c5925ee5.pth'
+resume = False
+launcher = 'none'
+work_dir = './work_dirs/faster-rcnn_r50-caffe_fpn_1x_coco'

inference/models/centernetbest.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0af1c3c2357dc6f4650e798e5aff8be01e93a2766a57548026622a10b40462a8
+size 140757155

inference/models/detrbest.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1dbffb3471ae7d9b4ad7a33977cebb38983e797dd7cb2180f314a42b9d99e80a
+size 213052547

inference/models/fasterrcnnbest.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8f25fcd2fe4bbfb27c3f62c667e9a4d337079ddb576bee01424a6bd8c225568
+size 169034569

inference/models/retinanetbest.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5addc6c1a9fa202b5192922559bd69c9c274774bb427cecded5bcbfcd6a59d72
+size 222922197

inference/models/rtmdetbest.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:047f9d0980a6517a2e8a436f7f6377b4bf04f0370a9a6906f317f691234b2464
+size 82940119

inference/models/ssdbest.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7463e3afedf144cb289a244b7548b33e0fd2b7255aa7580606ce4a1dc2733e1
+size 28107401

inference/models/yolov5best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51fce45b8130940c74f07fcda686a120648d75b6d4d9f2f9287b4769f9029608
+size 172984812

inference/models/yolov8best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffaab64d2ad6ecaeca6d79066c95b8602060469bf28edf21caeb5df6d32daf2b
+size 136739881

inference/retinanet_config.py

@@ -0,0 +1,343 @@
+dataset_type = 'CocoDataset'
+data_root = '/home/safouane/Downloads/benchmark_aircraft/data/'
+backend_args = None
+max_epochs = 500
+metainfo = {
+    'classes': ('airplane', ),
+    'palette': [
+        (0, 128, 255),
+    ]
+}
+num_classes = 1
+model = dict(
+    type='RetinaNet',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[
+            123.675,
+            116.28,
+            103.53,
+        ],
+        std=[
+            58.395,
+            57.12,
+            57.375,
+        ],
+        bgr_to_rgb=True,
+        pad_size_divisor=64,
+        batch_augments=[
+            dict(type='BatchFixedSizePad', size=(
+                640,
+                640,
+            )),
+        ]),
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        num_stages=4,
+        out_indices=(
+            0,
+            1,
+            2,
+            3,
+        ),
+        frozen_stages=1,
+        norm_cfg=dict(type='BN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    neck=dict(
+        type='FPN',
+        in_channels=[
+            256,
+            512,
+            1024,
+            2048,
+        ],
+        out_channels=256,
+        start_level=1,
+        add_extra_convs='on_input',
+        num_outs=5,
+        relu_before_extra_convs=True,
+        no_norm_on_lateral=True,
+        norm_cfg=dict(type='BN', requires_grad=True)),
+    bbox_head=dict(
+        type='RetinaSepBNHead',
+        num_classes=1,
+        in_channels=256,
+        stacked_convs=4,
+        feat_channels=256,
+        anchor_generator=dict(
+            type='AnchorGenerator',
+            octave_base_scale=4,
+            scales_per_octave=3,
+            ratios=[
+                0.5,
+                1.0,
+                2.0,
+            ],
+            strides=[
+                8,
+                16,
+                32,
+                64,
+                128,
+            ]),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+            ],
+            target_stds=[
+                1.0,
+                1.0,
+                1.0,
+                1.0,
+            ]),
+        loss_cls=dict(
+            type='FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(type='L1Loss', loss_weight=1.0),
+        num_ins=5,
+        norm_cfg=dict(type='BN', requires_grad=True)),
+    train_cfg=dict(
+        assigner=dict(
+            type='MaxIoUAssigner',
+            pos_iou_thr=0.5,
+            neg_iou_thr=0.5,
+            min_pos_iou=0,
+            ignore_iof_thr=-1),
+        sampler=dict(type='PseudoSampler'),
+        allowed_border=-1,
+        pos_weight=-1,
+        debug=False),
+    test_cfg=dict(
+        nms_pre=1000,
+        min_bbox_size=0,
+        score_thr=0.05,
+        nms=dict(type='nms', iou_threshold=0.5),
+        max_per_img=100))
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='RandomResize',
+        scale=(
+            640,
+            640,
+        ),
+        ratio_range=(
+            0.8,
+            1.2,
+        ),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=(
+        640,
+        640,
+    )),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs'),
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='Resize', scale=(
+        640,
+        640,
+    ), keep_ratio=True),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=(
+            'img_id',
+            'img_path',
+            'ori_shape',
+            'img_shape',
+            'scale_factor',
+        )),
+]
+train_dataloader = dict(
+    batch_size=32,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    batch_sampler=dict(type='AspectRatioBatchSampler'),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='train/__coco.json',
+        data_prefix=dict(img='train/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='RandomResize',
+                scale=(
+                    640,
+                    640,
+                ),
+                ratio_range=(
+                    0.8,
+                    1.2,
+                ),
+                keep_ratio=True),
+            dict(type='RandomCrop', crop_size=(
+                640,
+                640,
+            )),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PackDetInputs'),
+        ],
+        backend_args=None))
+val_dataloader = dict(
+    batch_size=32,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='val/__coco.json',
+        data_prefix=dict(img='val/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                640,
+                640,
+            ), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='test/__coco.json',
+        data_prefix=dict(img='test/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                640,
+                640,
+            ), keep_ratio=True),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file='/home/safouane/Downloads/benchmark_aircraft/data/val/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+test_evaluator = dict(
+    type='CocoMetric',
+    ann_file=
+    '/home/safouane/Downloads/benchmark_aircraft/data/test/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=500, val_interval=10)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+param_scheduler = [
+    dict(type='LinearLR', start_factor=0.1, by_epoch=False, begin=0, end=1000),
+    dict(
+        type='MultiStepLR',
+        begin=0,
+        end=50,
+        by_epoch=True,
+        milestones=[
+            30,
+            40,
+        ],
+        gamma=0.1),
+]
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.015, momentum=0.9, weight_decay=0.0001),
+    paramwise_cfg=dict(norm_decay_mult=0, bypass_duplicate=True))
+auto_scale_lr = dict(enable=False, base_batch_size=64)
+default_scope = 'mmdet'
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(
+        type='CheckpointHook', interval=20, max_keep_ckpts=2,
+        save_best='auto'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='DetVisualizationHook'))
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+vis_backends = [
+    dict(type='LocalVisBackend'),
+]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=[
+        dict(type='LocalVisBackend'),
+        dict(type='TensorboardVisBackend'),
+    ],
+    name='visualizer')
+log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True)
+log_level = 'INFO'
+load_from = '/home/safouane/Downloads/benchmark_aircraft/mmlab_configs/retinanet_r50_fpn_crop640_50e_coco-9b953d76.pth'
+resume = False
+norm_cfg = dict(type='BN', requires_grad=True)
+launcher = 'none'
+work_dir = './work_dirs/retinanet_r50_fpn_crop640-50e_coco'

inference/rtmdet_config.py

@@ -0,0 +1,562 @@
+default_scope = 'mmdet'
+dataset_type = 'CocoDataset'
+data_root = '/home/safouane/Downloads/benchmark_aircraft/data/'
+backend_args = None
+batch_size = 64
+max_epochs = 300
+metainfo = {
+    'classes': ('airplane', ),
+    'palette': [
+        (0, 128, 255),
+    ]
+}
+num_classes = 1
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', interval=10, max_keep_ckpts=3),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='DetVisualizationHook'))
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+vis_backends = [
+    dict(type='LocalVisBackend'),
+]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=[
+        dict(type='LocalVisBackend'),
+        dict(type='TensorboardVisBackend'),
+    ],
+    name='visualizer')
+log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True)
+log_level = 'INFO'
+load_from = '/home/safouane/Downloads/benchmark_aircraft/mmdetection/configs/rtmdet/checkpoints/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'
+resume = False
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=500, val_interval=10)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=1e-05, by_epoch=False, begin=0,
+        end=1000),
+    dict(
+        type='CosineAnnealingLR',
+        eta_min=0.0002,
+        begin=150,
+        end=300,
+        T_max=150,
+        by_epoch=True,
+        convert_to_iter_based=True),
+]
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='AdamW', lr=0.004, weight_decay=0.05),
+    paramwise_cfg=dict(
+        norm_decay_mult=0, bias_decay_mult=0, bypass_duplicate=True))
+auto_scale_lr = dict(enable=False, base_batch_size=16)
+train_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='CachedMosaic',
+        img_scale=(
+            640,
+            640,
+        ),
+        pad_val=114.0,
+        max_cached_images=20,
+        random_pop=False),
+    dict(
+        type='RandomResize',
+        scale=(
+            1280,
+            1280,
+        ),
+        ratio_range=(
+            0.5,
+            2.0,
+        ),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=(
+        640,
+        640,
+    )),
+    dict(type='YOLOXHSVRandomAug'),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='Pad', size=(
+        640,
+        640,
+    ), pad_val=dict(img=(
+        114,
+        114,
+        114,
+    ))),
+    dict(
+        type='CachedMixUp',
+        img_scale=(
+            640,
+            640,
+        ),
+        ratio_range=(
+            1.0,
+            1.0,
+        ),
+        max_cached_images=10,
+        random_pop=False,
+        pad_val=(
+            114,
+            114,
+            114,
+        ),
+        prob=0.5),
+    dict(type='PackDetInputs'),
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='Resize', scale=(
+        640,
+        640,
+    ), keep_ratio=True),
+    dict(type='Pad', size=(
+        640,
+        640,
+    ), pad_val=dict(img=(
+        114,
+        114,
+        114,
+    ))),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=(
+            'img_id',
+            'img_path',
+            'ori_shape',
+            'img_shape',
+            'scale_factor',
+        )),
+]
+train_dataloader = dict(
+    batch_size=64,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    batch_sampler=None,
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='train/__coco.json',
+        data_prefix=dict(img='train/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='CachedMosaic',
+                img_scale=(
+                    640,
+                    640,
+                ),
+                pad_val=114.0,
+                max_cached_images=20,
+                random_pop=False),
+            dict(
+                type='RandomResize',
+                scale=(
+                    1280,
+                    1280,
+                ),
+                ratio_range=(
+                    0.5,
+                    2.0,
+                ),
+                keep_ratio=True),
+            dict(type='RandomCrop', crop_size=(
+                640,
+                640,
+            )),
+            dict(type='YOLOXHSVRandomAug'),
+            dict(type='RandomFlip', prob=0.5),
+            dict(
+                type='Pad',
+                size=(
+                    640,
+                    640,
+                ),
+                pad_val=dict(img=(
+                    114,
+                    114,
+                    114,
+                ))),
+            dict(
+                type='CachedMixUp',
+                img_scale=(
+                    640,
+                    640,
+                ),
+                ratio_range=(
+                    1.0,
+                    1.0,
+                ),
+                max_cached_images=10,
+                random_pop=False,
+                pad_val=(
+                    114,
+                    114,
+                    114,
+                ),
+                prob=0.5),
+            dict(type='PackDetInputs'),
+        ],
+        backend_args=None),
+    pin_memory=True)
+val_dataloader = dict(
+    batch_size=64,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='val/__coco.json',
+        data_prefix=dict(img='val/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                640,
+                640,
+            ), keep_ratio=True),
+            dict(
+                type='Pad',
+                size=(
+                    640,
+                    640,
+                ),
+                pad_val=dict(img=(
+                    114,
+                    114,
+                    114,
+                ))),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+test_dataloader = dict(
+    batch_size=64,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='test/__coco.json',
+        data_prefix=dict(img='test/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='Resize', scale=(
+                640,
+                640,
+            ), keep_ratio=True),
+            dict(
+                type='Pad',
+                size=(
+                    640,
+                    640,
+                ),
+                pad_val=dict(img=(
+                    114,
+                    114,
+                    114,
+                ))),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file='/home/safouane/Downloads/benchmark_aircraft/data/val/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+test_evaluator = dict(
+    type='CocoMetric',
+    ann_file=
+    '/home/safouane/Downloads/benchmark_aircraft/data/test/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+tta_model = dict(
+    type='DetTTAModel',
+    tta_cfg=dict(nms=dict(type='nms', iou_threshold=0.6), max_per_img=100))
+img_scales = [
+    (
+        640,
+        640,
+    ),
+    (
+        320,
+        320,
+    ),
+    (
+        960,
+        960,
+    ),
+]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[
+            [
+                dict(type='Resize', scale=(
+                    640,
+                    640,
+                ), keep_ratio=True),
+                dict(type='Resize', scale=(
+                    320,
+                    320,
+                ), keep_ratio=True),
+                dict(type='Resize', scale=(
+                    960,
+                    960,
+                ), keep_ratio=True),
+            ],
+            [
+                dict(type='RandomFlip', prob=1.0),
+                dict(type='RandomFlip', prob=0.0),
+            ],
+            [
+                dict(
+                    type='Pad',
+                    size=(
+                        960,
+                        960,
+                    ),
+                    pad_val=dict(img=(
+                        114,
+                        114,
+                        114,
+                    ))),
+            ],
+            [
+                dict(type='LoadAnnotations', with_bbox=True),
+            ],
+            [
+                dict(
+                    type='PackDetInputs',
+                    meta_keys=(
+                        'img_id',
+                        'img_path',
+                        'ori_shape',
+                        'img_shape',
+                        'scale_factor',
+                        'flip',
+                        'flip_direction',
+                    )),
+            ],
+        ]),
+]
+model = dict(
+    type='RTMDet',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[
+            103.53,
+            116.28,
+            123.675,
+        ],
+        std=[
+            57.375,
+            57.12,
+            58.395,
+        ],
+        bgr_to_rgb=False,
+        batch_augments=None),
+    backbone=dict(
+        type='CSPNeXt',
+        arch='P5',
+        expand_ratio=0.5,
+        deepen_factor=0.167,
+        widen_factor=0.375,
+        channel_attention=True,
+        norm_cfg=dict(type='SyncBN'),
+        act_cfg=dict(type='SiLU', inplace=True),
+        init_cfg=dict(
+            type='Pretrained',
+            prefix='backbone.',
+            checkpoint=
+            'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth'
+        )),
+    neck=dict(
+        type='CSPNeXtPAFPN',
+        in_channels=[
+            96,
+            192,
+            384,
+        ],
+        out_channels=96,
+        num_csp_blocks=1,
+        expand_ratio=0.5,
+        norm_cfg=dict(type='SyncBN'),
+        act_cfg=dict(type='SiLU', inplace=True)),
+    bbox_head=dict(
+        type='RTMDetSepBNHead',
+        num_classes=1,
+        in_channels=96,
+        stacked_convs=2,
+        feat_channels=96,
+        anchor_generator=dict(
+            type='MlvlPointGenerator', offset=0, strides=[
+                8,
+                16,
+                32,
+            ]),
+        bbox_coder=dict(type='DistancePointBBoxCoder'),
+        loss_cls=dict(
+            type='QualityFocalLoss',
+            use_sigmoid=True,
+            beta=2.0,
+            loss_weight=1.0),
+        loss_bbox=dict(type='GIoULoss', loss_weight=2.0),
+        with_objectness=False,
+        exp_on_reg=False,
+        share_conv=True,
+        pred_kernel_size=1,
+        norm_cfg=dict(type='SyncBN'),
+        act_cfg=dict(type='SiLU', inplace=True)),
+    train_cfg=dict(
+        assigner=dict(type='DynamicSoftLabelAssigner', topk=13),
+        allowed_border=-1,
+        pos_weight=-1,
+        debug=False),
+    test_cfg=dict(
+        nms_pre=30000,
+        min_bbox_size=0,
+        score_thr=0.001,
+        nms=dict(type='nms', iou_threshold=0.65),
+        max_per_img=300))
+train_pipeline_stage2 = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='RandomResize',
+        scale=(
+            640,
+            640,
+        ),
+        ratio_range=(
+            0.5,
+            2.0,
+        ),
+        keep_ratio=True),
+    dict(type='RandomCrop', crop_size=(
+        640,
+        640,
+    )),
+    dict(type='YOLOXHSVRandomAug'),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='Pad', size=(
+        640,
+        640,
+    ), pad_val=dict(img=(
+        114,
+        114,
+        114,
+    ))),
+    dict(type='PackDetInputs'),
+]
+stage2_num_epochs = 20
+base_lr = 0.004
+interval = 10
+custom_hooks = [
+    dict(
+        type='EMAHook',
+        ema_type='ExpMomentumEMA',
+        momentum=0.0002,
+        update_buffers=True,
+        priority=49),
+    dict(
+        type='PipelineSwitchHook',
+        switch_epoch=280,
+        switch_pipeline=[
+            dict(type='LoadImageFromFile', backend_args=None),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='RandomResize',
+                scale=(
+                    640,
+                    640,
+                ),
+                ratio_range=(
+                    0.5,
+                    2.0,
+                ),
+                keep_ratio=True),
+            dict(type='RandomCrop', crop_size=(
+                640,
+                640,
+            )),
+            dict(type='YOLOXHSVRandomAug'),
+            dict(type='RandomFlip', prob=0.5),
+            dict(
+                type='Pad',
+                size=(
+                    640,
+                    640,
+                ),
+                pad_val=dict(img=(
+                    114,
+                    114,
+                    114,
+                ))),
+            dict(type='PackDetInputs'),
+        ]),
+]
+checkpoint = 'https://download.openmmlab.com/mmdetection/v3.0/rtmdet/cspnext_rsb_pretrain/cspnext-tiny_imagenet_600e.pth'
+launcher = 'none'
+work_dir = './work_dirs/rtmdet_tiny_8xb32-300e_coco'

inference/ssd_config.py

@@ -0,0 +1,450 @@
+dataset_type = 'CocoDataset'
+data_root = '/home/safouane/Downloads/benchmark_aircraft/data/'
+backend_args = None
+max_epochs = 500
+metainfo = dict(
+    classes=('airplane', ), palette=[
+        (
+            0,
+            0,
+            255,
+        ),
+    ])
+num_classes = 1
+batch_size = 128
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='Expand',
+        mean=[
+            123.675,
+            116.28,
+            103.53,
+        ],
+        to_rgb=True,
+        ratio_range=(
+            1,
+            4,
+        )),
+    dict(
+        type='MinIoURandomCrop',
+        min_ious=(
+            0.1,
+            0.3,
+            0.5,
+            0.7,
+            0.9,
+        ),
+        min_crop_size=0.3),
+    dict(type='Resize', scale=(
+        320,
+        320,
+    ), keep_ratio=False),
+    dict(type='RandomFlip', prob=0.5),
+    dict(
+        type='PhotoMetricDistortion',
+        brightness_delta=32,
+        contrast_range=(
+            0.5,
+            1.5,
+        ),
+        saturation_range=(
+            0.5,
+            1.5,
+        ),
+        hue_delta=18),
+    dict(type='PackDetInputs'),
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(
+        320,
+        320,
+    ), keep_ratio=False),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=(
+            'img_id',
+            'img_path',
+            'ori_shape',
+            'img_shape',
+            'scale_factor',
+        )),
+]
+train_dataloader = dict(
+    batch_size=128,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    batch_sampler=None,
+    dataset=dict(
+        type='RepeatDataset',
+        times=5,
+        dataset=dict(
+            type='CocoDataset',
+            metainfo=dict(classes=('airplane', ), palette=[
+                (
+                    220,
+                    20,
+                    60,
+                ),
+            ]),
+            data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+            ann_file='train/__coco.json',
+            data_prefix=dict(img='train/'),
+            filter_cfg=dict(filter_empty_gt=True, min_size=32),
+            pipeline=[
+                dict(type='LoadImageFromFile'),
+                dict(type='LoadAnnotations', with_bbox=True),
+                dict(
+                    type='Expand',
+                    mean=[
+                        123.675,
+                        116.28,
+                        103.53,
+                    ],
+                    to_rgb=True,
+                    ratio_range=(
+                        1,
+                        4,
+                    )),
+                dict(
+                    type='MinIoURandomCrop',
+                    min_ious=(
+                        0.1,
+                        0.3,
+                        0.5,
+                        0.7,
+                        0.9,
+                    ),
+                    min_crop_size=0.3),
+                dict(type='Resize', scale=(
+                    320,
+                    320,
+                ), keep_ratio=False),
+                dict(type='RandomFlip', prob=0.5),
+                dict(
+                    type='PhotoMetricDistortion',
+                    brightness_delta=32,
+                    contrast_range=(
+                        0.5,
+                        1.5,
+                    ),
+                    saturation_range=(
+                        0.5,
+                        1.5,
+                    ),
+                    hue_delta=18),
+                dict(type='PackDetInputs'),
+            ])))
+val_dataloader = dict(
+    batch_size=128,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='val/__coco.json',
+        data_prefix=dict(img='val/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=(
+                320,
+                320,
+            ), keep_ratio=False),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+test_dataloader = dict(
+    batch_size=128,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='CocoDataset',
+        metainfo=dict(classes=('airplane', ), palette=[
+            (
+                220,
+                20,
+                60,
+            ),
+        ]),
+        data_root='/home/safouane/Downloads/benchmark_aircraft/data/',
+        ann_file='test/__coco.json',
+        data_prefix=dict(img='test/'),
+        test_mode=True,
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=(
+                320,
+                320,
+            ), keep_ratio=False),
+            dict(type='LoadAnnotations', with_bbox=True),
+            dict(
+                type='PackDetInputs',
+                meta_keys=(
+                    'img_id',
+                    'img_path',
+                    'ori_shape',
+                    'img_shape',
+                    'scale_factor',
+                )),
+        ],
+        backend_args=None))
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file='/home/safouane/Downloads/benchmark_aircraft/data/val/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+test_evaluator = dict(
+    type='CocoMetric',
+    ann_file=
+    '/home/safouane/Downloads/benchmark_aircraft/data/test/__coco.json',
+    metric='bbox',
+    format_only=False,
+    backend_args=None)
+train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=500, val_interval=1)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=0.001, by_epoch=False, begin=0, end=500),
+    dict(
+        type='CosineAnnealingLR',
+        begin=0,
+        T_max=120,
+        end=120,
+        by_epoch=True,
+        eta_min=0),
+]
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(type='SGD', lr=0.015, momentum=0.9, weight_decay=4e-05))
+auto_scale_lr = dict(enable=False, base_batch_size=64)
+default_scope = 'mmdet'
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', interval=20, save_best='auto'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='DetVisualizationHook'))
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+vis_backends = [
+    dict(type='LocalVisBackend'),
+]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=[
+        dict(type='LocalVisBackend'),
+        dict(type='TensorboardVisBackend'),
+    ],
+    name='visualizer')
+log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True)
+log_level = 'INFO'
+load_from = '/home/safouane/Downloads/benchmark_aircraft/mmdetection/configs/ssd/checkpoints/ssdlite_mobilenetv2_scratch_600e_coco_20210629_110627-974d9307.pth'
+resume = False
+data_preprocessor = dict(
+    type='DetDataPreprocessor',
+    mean=[
+        123.675,
+        116.28,
+        103.53,
+    ],
+    std=[
+        58.395,
+        57.12,
+        57.375,
+    ],
+    bgr_to_rgb=True,
+    pad_size_divisor=1)
+model = dict(
+    type='SingleStageDetector',
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        mean=[
+            123.675,
+            116.28,
+            103.53,
+        ],
+        std=[
+            58.395,
+            57.12,
+            57.375,
+        ],
+        bgr_to_rgb=True,
+        pad_size_divisor=1),
+    backbone=dict(
+        type='MobileNetV2',
+        out_indices=(
+            4,
+            7,
+        ),
+        norm_cfg=dict(type='BN', eps=0.001, momentum=0.03),
+        init_cfg=dict(type='TruncNormal', layer='Conv2d', std=0.03)),
+    neck=dict(
+        type='SSDNeck',
+        in_channels=(
+            96,
+            1280,
+        ),
+        out_channels=(
+            96,
+            1280,
+            512,
+            256,
+            256,
+            128,
+        ),
+        level_strides=(
+            2,
+            2,
+            2,
+            2,
+        ),
+        level_paddings=(
+            1,
+            1,
+            1,
+            1,
+        ),
+        l2_norm_scale=None,
+        use_depthwise=True,
+        norm_cfg=dict(type='BN', eps=0.001, momentum=0.03),
+        act_cfg=dict(type='ReLU6'),
+        init_cfg=dict(type='TruncNormal', layer='Conv2d', std=0.03)),
+    bbox_head=dict(
+        type='SSDHead',
+        in_channels=(
+            96,
+            1280,
+            512,
+            256,
+            256,
+            128,
+        ),
+        num_classes=1,
+        use_depthwise=True,
+        norm_cfg=dict(type='BN', eps=0.001, momentum=0.03),
+        act_cfg=dict(type='ReLU6'),
+        init_cfg=dict(type='Normal', layer='Conv2d', std=0.001),
+        anchor_generator=dict(
+            type='SSDAnchorGenerator',
+            scale_major=False,
+            strides=[
+                16,
+                32,
+                64,
+                107,
+                160,
+                320,
+            ],
+            ratios=[
+                [
+                    2,
+                    3,
+                ],
+                [
+                    2,
+                    3,
+                ],
+                [
+                    2,
+                    3,
+                ],
+                [
+                    2,
+                    3,
+                ],
+                [
+                    2,
+                    3,
+                ],
+                [
+                    2,
+                    3,
+                ],
+            ],
+            min_sizes=[
+                48,
+                100,
+                150,
+                202,
+                253,
+                304,
+            ],
+            max_sizes=[
+                100,
+                150,
+                202,
+                253,
+                304,
+                320,
+            ]),
+        bbox_coder=dict(
+            type='DeltaXYWHBBoxCoder',
+            target_means=[
+                0.0,
+                0.0,
+                0.0,
+                0.0,
+            ],
+            target_stds=[
+                0.1,
+                0.1,
+                0.2,
+                0.2,
+            ])),
+    train_cfg=dict(
+        assigner=dict(
+            type='MaxIoUAssigner',
+            pos_iou_thr=0.5,
+            neg_iou_thr=0.5,
+            min_pos_iou=0.0,
+            ignore_iof_thr=-1,
+            gt_max_assign_all=False),
+        sampler=dict(type='PseudoSampler'),
+        smoothl1_beta=1.0,
+        allowed_border=-1,
+        pos_weight=-1,
+        neg_pos_ratio=3,
+        debug=False),
+    test_cfg=dict(
+        nms_pre=1000,
+        nms=dict(type='nms', iou_threshold=0.45),
+        min_bbox_size=0,
+        score_thr=0.02,
+        max_per_img=200))
+input_size = 320
+custom_hooks = [
+    dict(type='NumClassCheckHook'),
+    dict(type='CheckInvalidLossHook', interval=50, priority='VERY_LOW'),
+]
+launcher = 'none'
+work_dir = './work_dirs/ssdlite_mobilenetv2-scratch_8xb24-600e_coco'

requirements.txt

@@ -0,0 +1,262 @@
+absl-py==1.3.0
+addict==2.4.0
+aiofiles==23.2.1
+aiohttp==3.8.3
+aiosignal==1.3.1
+aliyun-python-sdk-core==2.15.0
+aliyun-python-sdk-kms==2.16.2
+altair==5.3.0
+annotated-types==0.6.0
+anyio==4.3.0
+apispec==6.0.2
+apispec-webframeworks==0.5.2
+asttokens==2.1.0
+astunparse==1.6.3
+async-timeout==4.0.2
+attrs==22.2.0
+backcall==0.2.0
+bidict==0.22.1
+bleach==4.1.0
+blessed==1.20.0
+blis==0.7.9
+Brotli @ file:///tmp/abs_ecyw11_7ze/croots/recipe/brotli-split_1659616059936/work
+cachelib==0.10.2
+cachetools==5.2.0
+catalogue==2.0.8
+certifi @ file:///croot/certifi_1707229174982/work/certifi
+cffi==1.15.1
+charset-normalizer==2.1.1
+click==8.1.7
+cmake==3.27.1
+colorama==0.4.6
+confection==0.0.3
+contourpy==1.0.6
+crcmod==1.7
+cryptography==42.0.5
+cycler==0.12.1
+cymem==2.0.7
+debugpy==1.6.3
+decorator==5.1.1
+dill==0.3.8
+dnspython==2.2.1
+entrypoints==0.4
+etils==0.9.0
+eventlet==0.33.3
+exceptiongroup==1.2.0
+executing==1.2.0
+fastai==2.7.10
+fastapi==0.110.1
+fastcore==1.5.27
+fastdownload==0.0.7
+fastprogress==1.0.3
+ffmpy==0.3.2
+filelock==3.12.2
+Flask==2.2.3
+flask-cloudflared==0.0.10
+flask-ngrok==0.0.25
+Flask-Session==0.4.0
+Flask-SocketIO==5.3.2
+fonttools==4.38.0
+frozenlist==1.3.3
+fsspec==2023.6.0
+gitdb==4.0.10
+GitPython==3.1.31
+gmpy2 @ file:///tmp/build/80754af9/gmpy2_1645455532332/work
+google-pasta==0.2.0
+googleapis-common-protos==1.57.0
+gpustat==1.1
+gradio==4.26.0
+gradio_client==0.15.1
+grpcio==1.50.0
+h11==0.14.0
+h5py==2.10.0
+httpcore==1.0.5
+httpx==0.27.0
+huggingface-hub==0.22.2
+HyperPyYAML==1.2.1
+idna @ file:///croot/idna_1666125576474/work
+importlib-resources==5.10.0
+importlib_metadata==7.1.0
+ipykernel==6.17.1
+ipython==8.6.0
+itsdangerous==2.1.2
+jedi==0.18.2
+Jinja2==3.1.2
+jmespath==0.10.0
+joblib==1.2.0
+jsonschema==4.21.1
+jsonschema-specifications==2023.12.1
+jupyter_client==7.4.7
+jupyter_core==5.7.2
+kiwisolver==1.4.4
+langcodes==3.3.0
+libclang==14.0.6
+lit==16.0.6
+loguru==0.6.0
+lupa==1.10
+Markdown==3.4.1
+markdown-it-py==3.0.0
+MarkupSafe==2.1.1
+marshmallow==3.19.0
+matplotlib==3.7.5
+matplotlib-inline==0.1.6
+mdurl==0.1.2
+mkl-fft @ file:///croot/mkl_fft_1695058164594/work
+mkl-random @ file:///croot/mkl_random_1695059800811/work
+mkl-service==2.4.0
+mkultra==0.1
+mmcv==2.1.0
+-e git+https://github.com/open-mmlab/mmdetection.git@cfd5d3a985b0249de009b67d04f37263e11cdf3d#egg=mmdet
+mmengine==0.10.3
+model-index==0.1.11
+monai==1.1.0
+mpmath==1.3.0
+multidict==6.0.4
+multiprocess==0.70.15
+murmurhash==1.0.9
+nest-asyncio==1.5.6
+networkx==3.0
+nibabel==5.0.0
+numpy @ file:///work/mkl/numpy_and_numpy_base_1682953417311/work
+nvidia-cublas-cu11==11.10.3.66
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu11==11.7.101
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvrtc-cu11==11.7.99
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu11==11.7.99
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu11==8.5.0.96
+nvidia-cudnn-cu12==8.9.2.26
+nvidia-cufft-cu11==10.9.0.58
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu11==10.2.10.91
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu11==11.4.0.1
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu11==11.7.4.91
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-ml-py==12.535.77
+nvidia-nccl-cu11==2.14.3
+nvidia-nccl-cu12==2.19.3
+nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvtx-cu11==11.7.91
+nvidia-nvtx-cu12==12.1.105
+opencv-python==4.9.0.80
+opendatalab==0.0.10
+openmim==0.3.9
+openxlab==0.0.38
+opt-einsum==3.3.0
+ordered-set==4.1.0
+orjson==3.10.0
+oss2==2.17.0
+packaging==24.0
+pandas==2.0.3
+parso==0.8.3
+pathy==0.10.0
+pexpect==4.9.0
+pickleshare==0.7.5
+pillow==10.3.0
+pkgutil_resolve_name==1.3.10
+platformdirs==4.2.0
+preshed==3.0.8
+progress==1.6
+promise==2.3
+prompt-toolkit==3.0.33
+psutil==5.9.4
+ptyprocess==0.7.0
+pure-eval==0.2.2
+py-cpuinfo==9.0.0
+pyarrow==12.0.1
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pycocotools==2.0.7
+pycparser==2.21
+pycryptodome==3.20.0
+pydantic==2.7.0
+pydantic_core==2.18.1
+pyDeprecate==0.3.1
+pydot==1.4.2
+pydub==0.25.1
+Pygments==2.13.0
+pyparsing==3.1.2
+PySocks @ file:///tmp/build/80754af9/pysocks_1605305779399/work
+python-dateutil==2.8.2
+python-engineio==4.3.4
+python-multipart==0.0.9
+python-socketio==5.7.2
+pytz==2023.4
+PyWavelets==1.4.1
+PyYAML==6.0.1
+pyzmq==24.0.1
+referencing==0.34.0
+regex==2022.10.31
+requests==2.28.2
+requests-oauthlib==1.3.1
+rich==13.4.2
+rpds-py==0.18.0
+rsa==4.9
+ruamel.yaml==0.17.28
+ruamel.yaml.clib==0.2.7
+ruff==0.3.7
+runstats==2.0.0
+safetensors==0.3.2
+scikit-learn==1.1.3
+scipy==1.10.1
+seaborn==0.12.2
+semantic-version==2.10.0
+sentencepiece==0.1.97
+shapely==2.0.3
+shellingham==1.5.4
+six==1.16.0
+smart-open==5.2.1
+smmap==5.0.0
+sniffio==1.3.1
+soundfile==0.12.1
+spacy==3.4.3
+spacy-legacy==3.0.10
+spacy-loggers==1.0.3
+speechbrain==0.5.15
+srsly==2.4.5
+stack-data==0.6.1
+starlette==0.37.2
+sympy==1.12
+tabulate==0.9.0
+tensorboard-plugin-wit==1.8.1
+tensorflow-datasets==4.7.0
+tensorflow-examples===e2510e7de8354ea89c54ab376ce52371efb39eff-
+tensorflow-hub==0.12.0
+tensorflow-io-gcs-filesystem==0.28.0
+tensorflow-metadata==1.11.0
+termcolor==2.1.1
+terminaltables==3.1.10
+thinc==8.1.5
+thop==0.1.1.post2209072238
+threadpoolctl==3.1.0
+toml==0.10.2
+tomli==2.0.1
+tomlkit==0.12.0
+toolz==0.12.1
+torch==2.0.1
+torch-tb-profiler==0.4.1
+torchaudio==2.0.2
+torchvision==0.15.2
+tornado==6.2
+tqdm==4.65.2
+traitlets==5.14.2
+triton==2.0.0
+typer==0.12.3
+typing_extensions==4.11.0
+tzdata==2023.3
+ultralytics==8.1.47
+urllib3==1.26.18
+uvicorn==0.29.0
+wasabi==0.10.1
+wcwidth==0.2.13
+webencodings==0.5.1
+websockets==11.0.3
+Werkzeug==2.2.2
+xxhash==3.3.0
+yapf==0.40.2
+yarl==1.8.2
+zipp==3.10.0

utils.py

@@ -0,0 +1,153 @@
+import os, ast
+from glob import glob 
+from PIL import ImageFont, ImageDraw, Image
+
+def process_txtfile(filename):
+    """
+    Read txt annotations files (designed for YOLO xywh format)
+
+    Parameters:
+        filename(str): path of the txt annotation file.
+
+    Returns:
+        segments: list of bboxes in format xmin, ymin, xmax, ymax (as image ratio)
+        confs: list of confidences of the bboxes object detection
+    """
+    segments = []
+    confs = []
+    with open(filename, 'r') as file:
+        for line in file:
+            # print(line)
+            line = line.strip().split(' ')
+            cls = int(line[0])
+            conf = line[5]
+            x, y, w, h = map(float, line[1:5])
+            x_min = x - (w / 2)
+            y_min = y - (h / 2)
+            x_max = x + (w / 2)
+            y_max = y + (h / 2)
+            segment = [x_min, y_min, x_max, y_max]
+            segments.append(segment)
+            confs.append(conf)
+
+    return segments, confs
+
+def process_jsonfile(filename):
+    """
+    Read json annotations files (designed for mmdetect dict format)
+
+    Parameters:
+        filename(str): path of the json annotation file.
+    
+    Returns:
+        segments: bboxes in format xmin, ymin, xmax, ymax (as px coordinates)
+        confs: list of confidences of the bboxes object detection
+    """
+    with open(filename, 'r') as file:
+        line = file.readline().strip() 
+        dic = ast.literal_eval(line)
+        segments = dic['bboxes']
+        confs = dic['scores']
+        # labels = dic['labels']
+
+    return segments, confs
+
+def lerp_color(color1, color2, t):
+    """
+    Linearly interpolate between two RGB colors.
+    
+    Parameters:
+        color1 (tuple): RGB tuple of the first color.
+        color2 (tuple): RGB tuple of the second color.
+        t (float): Interpolation factor between 0 and 1.
+        
+    Returns:
+        tuple: Interpolated RGB color tuple.
+    """
+    r = int(color1[0] + (color2[0] - color1[0]) * t)
+    g = int(color1[1] + (color2[1] - color1[1]) * t)
+    b = int(color1[2] + (color2[2] - color1[2]) * t)
+    return r, g, b
+
+def generate_color_palette(start_color, end_color, steps):
+    """
+    Generate an RGB color palette between two colors.
+    
+    Parameters:
+        start_color (tuple): RGB tuple of the starting color.
+        end_color (tuple): RGB tuple of the ending color.
+        steps (int): Number of steps between the two colors.
+        
+    Returns:
+        list: List of RGB tuples 
+    """
+    palette = []
+    for i in range(steps):
+        t = i / (steps - 1)  # interpolation factor
+        color = lerp_color(start_color, end_color, t)
+        palette.append(color)
+
+    return palette
+
+def draw_bbox(model_name, results_folder="./inference/results/", image_path="inptest.jpg"):
+    """
+    Draw bounding boxes from mmdetect or yolo formats
+    """
+
+    # annotations style
+    txt_color=(255, 255, 255)
+    yellow=(255, 255, 128)
+    black = (0, 0, 0)
+    steps = 11                 # Step : 5%
+    # (255, 0, 0)  # Red
+    # (0, 0, 255)    # Blue
+    palette = generate_color_palette((255, 0, 0), (0, 0, 255), steps)
+    lw = 9
+    font = ImageFont.truetype(font="Pillow/Tests/fonts/FreeMono.ttf", size=48)
+
+    im = Image.open(image_path)
+    width, height = im.size
+    imdraw = ImageDraw.Draw(im)
+
+    exps = sorted(glob(f"inference/results/{model_name}_inference/*", recursive = True))
+    # print(exps)
+    if model_name[:4] == "yolo":
+        annot_file = glob(f"{exps[-1]}/labels/" + "*.txt")[0]
+        segments, confs = process_txtfile(annot_file)
+    else:
+        annot_file = glob(f"{exps[1]}/{image_path[:-4]}.json")[0]
+        segments, confs = process_jsonfile(annot_file)
+    # print("Result bboxes : " + annot_file)    
+
+    for conf, box in  zip(confs, segments): 
+        conf_r = round(float(conf), 3) # round conf
+
+        if conf_r >= 0.5: # 0.5 threshold
+            bbox_c = palette[1] #
+            if conf_r <= 1.0: bbox_c = palette[-1]
+            if conf_r < 0.95: bbox_c = palette[-2]
+            if conf_r < 0.90: bbox_c = palette[-3]
+            if conf_r < 0.85: bbox_c = palette[-4]
+            if conf_r < 0.80: bbox_c = palette[-5]
+            if conf_r < 0.75: bbox_c = palette[-6]
+            if conf_r < 0.70: bbox_c = palette[-7]
+            if conf_r < 0.65: bbox_c = palette[-8]
+            if conf_r < 0.60: bbox_c = palette[-9]
+            if conf_r < 0.55: bbox_c = palette[-10]
+
+            if model_name[:4] == "yolo": 
+                box = [box[0]*width, box[1]*height, box[2]*width, box[3]*height]
+            imdraw.rectangle(box, width=lw, outline=bbox_c)  # box
+
+            # label
+            w, h = font.getbbox(str(conf_r))[2:4] # text w, h
+            imdraw.rectangle([box[0], box[1]-h, box[0]+w+1, box[1]+1], width=3, fill = black)  # box
+            imdraw.text([box[0], box[1]-h], str(conf_r), fill=yellow, font=font)
+            
+        im.save(f"{results_folder}{model_name}_inference/clean.jpg")
+
+    # count
+    count = len([i for i in confs if float(i) > 0.5])
+
+    return im, count
+