2.MM-Detection模型的训练、验证、预测、导出

已于 2024-06-04 11:31:07 修改
阅读量315 收藏
点赞数
文章标签： 人工智能 深度学习
于 2023-10-07 09:26:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jumy_S/article/details/133632376
版权

2.MM-Detection模型的训练、验证、预测、导出

一 训练模型

1.放置数据集到固定位置

在这里插入图片描述

在这里插入图片描述

手动转换成coco2017文件夹格式
在这里插入图片描述

2.修改图像大小和类别数

2.1 修改数据集读图大小

coco_detection.py
coco_instance.py
coco_instance_semantic.py

在这里插入图片描述

2.2 修改模型的输出类别数（以mask-rcnn为例）

在这里插入图片描述

在这里插入图片描述

3.修改评估的类别名称

在这里插入图片描述

4.修改coco.py文件中类别名称

在这里插入图片描述

5.训练

python tools/train.py .\configs\mask_rcnn\mask-rcnn_r50_fpn_1x_coco.py --gpus 1 --work-dir major_test

在这里插入图片描述
在这里插入图片描述

mask-rcnn_r50_fpn.py

# model settings
model = dict(
    type='MaskRCNN',
    data_preprocessor=dict(
        type='DetDataPreprocessor',
        mean=[123.675, 116.28, 103.53],
        std=[58.395, 57.12, 57.375],
        bgr_to_rgb=True,
        pad_mask=True,
        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=True),
        norm_eval=True,
        style='pytorch',
        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
    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],
            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=2,
            bbox_coder=dict(
                type='DeltaXYWHBBoxCoder',
                target_means=[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)),
        mask_roi_extractor=dict(
            type='SingleRoIExtractor',
            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
            out_channels=256,
            featmap_strides=[4, 8, 16, 32]),
        mask_head=dict(
            type='FCNMaskHead',
            num_convs=4,
            in_channels=256,
            conv_out_channels=256,
            num_classes=2,
            loss_mask=dict(
                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
    # model training and testing settings
    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=True,
                ignore_iof_thr=-1),
            sampler=dict(
                type='RandomSampler',
                num=512,
                pos_fraction=0.25,
                neg_pos_ub=-1,
                add_gt_as_proposals=True),
            mask_size=28,
            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,
            mask_thr_binary=0.5)))

coco_instance.py

# dataset settings
dataset_type = 'CocoDataset'
data_root = 'data/coco/'

# Example to use different file client
# Method 1: simply set the data root and let the file I/O module
# automatically infer from prefix (not support LMDB and Memcache yet)

# data_root = 's3://openmmlab/datasets/detection/coco/'

# Method 2: Use `backend_args`, `file_client_args` in versions before 3.0.0rc6
# backend_args = dict(
#     backend='petrel',
#     path_mapping=dict({
#         './data/': 's3://openmmlab/datasets/detection/',
#         'data/': 's3://openmmlab/datasets/detection/'
#     }))
backend_args = None

train_pipeline = [
    dict(type='LoadImageFromFile', backend_args=backend_args),
    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
    dict(type='Resize', scale=(512, 512), keep_ratio=True),
    dict(type='RandomFlip', prob=0.5),
    dict(type='PackDetInputs')
]
test_pipeline = [
    dict(type='LoadImageFromFile', backend_args=backend_args),
    dict(type='Resize', scale=(512, 512), keep_ratio=True),
    # If you don't have a gt annotation, delete the pipeline
    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
    dict(
        type='PackDetInputs',
        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
                   'scale_factor'))
]
train_dataloader = dict(
    batch_size=2,
    num_workers=2,
    persistent_workers=True,
    sampler=dict(type='DefaultSampler', shuffle=True),
    batch_sampler=dict(type='AspectRatioBatchSampler'),
    dataset=dict(
        type=dataset_type,
        data_root=data_root,
        ann_file='annotations/instances_train2017.json',
        data_prefix=dict(img='train2017/'),
        filter_cfg=dict(filter_empty_gt=True, min_size=32),
        pipeline=train_pipeline,
        backend_args=backend_args))
val_dataloader = dict(
    batch_size=1,
    num_workers=2,
    persistent_workers=True,
    drop_last=False,
    sampler=dict(type='DefaultSampler', shuffle=False),
    dataset=dict(
        type=dataset_type,
        data_root=data_root,
        ann_file='annotations/instances_val2017.json',
        data_prefix=dict(img='val2017/'),
        test_mode=True,
        pipeline=test_pipeline,
        backend_args=backend_args))
test_dataloader = val_dataloader

val_evaluator = dict(
    type='CocoMetric',
    ann_file=data_root + 'annotations/instances_val2017.json',
    metric=['bbox', 'segm'],
    format_only=False,
    backend_args=backend_args)
test_evaluator = val_evaluator

# inference on test dataset and
# format the output results for submission.
# test_dataloader = dict(
#     batch_size=1,
#     num_workers=2,
#     persistent_workers=True,
#     drop_last=False,
#     sampler=dict(type='DefaultSampler', shuffle=False),
#     dataset=dict(
#         type=dataset_type,
#         data_root=data_root,
#         ann_file=data_root + 'annotations/image_info_test-dev2017.json',
#         data_prefix=dict(img='test2017/'),
#         test_mode=True,
#         pipeline=test_pipeline))
# test_evaluator = dict(
#     type='CocoMetric',
#     metric=['bbox', 'segm'],
#     format_only=True,
#     ann_file=data_root + 'annotations/image_info_test-dev2017.json',
#     outfile_prefix='./work_dirs/coco_instance/test')

schedule_1x.py

# training schedule for 1x
train_cfg = dict(type='EpochBasedTrainLoop', max_epochs=12, val_interval=1)
val_cfg = dict(type='ValLoop')
test_cfg = dict(type='TestLoop')

# learning rate
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)
]

# optimizer
optim_wrapper = dict(
    type='OptimWrapper',
    optimizer=dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001))

# Default setting for scaling LR automatically
#   - `enable` means enable scaling LR automatically
#       or not by default.
#   - `base_batch_size` = (8 GPUs) x (2 samples per GPU).
auto_scale_lr = dict(enable=False, base_batch_size=16)

default_runtime.py

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=1),
    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=vis_backends, name='visualizer')
log_processor = dict(type='LogProcessor', window_size=50, by_epoch=True)

log_level = 'INFO'
load_from = None
resume = False

6.正式训练

训练后，在导出目录下有mask-rcnn_r50_fpn_1x_coco.py

后面在该py文件，修改各类参数，如epoch等，再以该py文件运行训练、验证，预测等操作

在这里插入图片描述


python tools/train.py major_test/mask-rcnn_r50_fpn_1x_coco.py --work-dir major_test

在这里插入图片描述

从什么模型开始训练
在这里插入图片描述

auto_scale_lr = dict(base_batch_size=16, enable=False)
backend_args = None
data_root = 'data/coco/'
dataset_type = 'CocoDataset'
default_hooks = dict(
    checkpoint=dict(interval=1, type='CheckpointHook'),
    logger=dict(interval=50, type='LoggerHook'),
    param_scheduler=dict(type='ParamSchedulerHook'),
    sampler_seed=dict(type='DistSamplerSeedHook'),
    timer=dict(type='IterTimerHook'),
    visualization=dict(type='DetVisualizationHook'))
default_scope = 'mmdet'
env_cfg = dict(
    cudnn_benchmark=False,
    dist_cfg=dict(backend='nccl'),
    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0))
launcher = 'none'
load_from = None
log_level = 'INFO'
log_processor = dict(by_epoch=True, type='LogProcessor', window_size=50)
model = dict(
    backbone=dict(
        depth=50,
        frozen_stages=1,
        init_cfg=dict(checkpoint='torchvision://resnet50', type='Pretrained'),
        norm_cfg=dict(requires_grad=True, type='BN'),
        norm_eval=True,
        num_stages=4,
        out_indices=(
            0,
            1,
            2,
            3,
        ),
        style='pytorch',
        type='ResNet'),
    data_preprocessor=dict(
        bgr_to_rgb=True,
        mean=[
            123.675,
            116.28,
            103.53,
        ],
        pad_mask=True,
        pad_size_divisor=32,
        std=[
            58.395,
            57.12,
            57.375,
        ],
        type='DetDataPreprocessor'),
    neck=dict(
        in_channels=[
            256,
            512,
            1024,
            2048,
        ],
        num_outs=5,
        out_channels=256,
        type='FPN'),
    roi_head=dict(
        bbox_head=dict(
            bbox_coder=dict(
                target_means=[
                    0.0,
                    0.0,
                    0.0,
                    0.0,
                ],
                target_stds=[
                    0.1,
                    0.1,
                    0.2,
                    0.2,
                ],
                type='DeltaXYWHBBoxCoder'),
            fc_out_channels=1024,
            in_channels=256,
            loss_bbox=dict(loss_weight=1.0, type='L1Loss'),
            loss_cls=dict(
                loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=False),
            num_classes=2,
            reg_class_agnostic=False,
            roi_feat_size=7,
            type='Shared2FCBBoxHead'),
        bbox_roi_extractor=dict(
            featmap_strides=[
                4,
                8,
                16,
                32,
            ],
            out_channels=256,
            roi_layer=dict(output_size=7, sampling_ratio=0, type='RoIAlign'),
            type='SingleRoIExtractor'),
        mask_head=dict(
            conv_out_channels=256,
            in_channels=256,
            loss_mask=dict(
                loss_weight=1.0, type='CrossEntropyLoss', use_mask=True),
            num_classes=2,
            num_convs=4,
            type='FCNMaskHead'),
        mask_roi_extractor=dict(
            featmap_strides=[
                4,
                8,
                16,
                32,
            ],
            out_channels=256,
            roi_layer=dict(output_size=14, sampling_ratio=0, type='RoIAlign'),
            type='SingleRoIExtractor'),
        type='StandardRoIHead'),
    rpn_head=dict(
        anchor_generator=dict(
            ratios=[
                0.5,
                1.0,
                2.0,
            ],
            scales=[
                8,
            ],
            strides=[
                4,
                8,
                16,
                32,
                64,
            ],
            type='AnchorGenerator'),
        bbox_coder=dict(
            target_means=[
                0.0,
                0.0,
                0.0,
                0.0,
            ],
            target_stds=[
                1.0,
                1.0,
                1.0,
                1.0,
            ],
            type='DeltaXYWHBBoxCoder'),
        feat_channels=256,
        in_channels=256,
        loss_bbox=dict(loss_weight=1.0, type='L1Loss'),
        loss_cls=dict(
            loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=True),
        type='RPNHead'),
    test_cfg=dict(
        rcnn=dict(
            mask_thr_binary=0.5,
            max_per_img=100,
            nms=dict(iou_threshold=0.5, type='nms'),
            score_thr=0.05),
        rpn=dict(
            max_per_img=1000,
            min_bbox_size=0,
            nms=dict(iou_threshold=0.7, type='nms'),
            nms_pre=1000)),
    train_cfg=dict(
        rcnn=dict(
            assigner=dict(
                ignore_iof_thr=-1,
                match_low_quality=True,
                min_pos_iou=0.5,
                neg_iou_thr=0.5,
                pos_iou_thr=0.5,
                type='MaxIoUAssigner'),
            debug=False,
            mask_size=28,
            pos_weight=-1,
            sampler=dict(
                add_gt_as_proposals=True,
                neg_pos_ub=-1,
                num=512,
                pos_fraction=0.25,
                type='RandomSampler')),
        rpn=dict(
            allowed_border=-1,
            assigner=dict(
                ignore_iof_thr=-1,
                match_low_quality=True,
                min_pos_iou=0.3,
                neg_iou_thr=0.3,
                pos_iou_thr=0.7,
                type='MaxIoUAssigner'),
            debug=False,
            pos_weight=-1,
            sampler=dict(
                add_gt_as_proposals=False,
                neg_pos_ub=-1,
                num=256,
                pos_fraction=0.5,
                type='RandomSampler')),
        rpn_proposal=dict(
            max_per_img=1000,
            min_bbox_size=0,
            nms=dict(iou_threshold=0.7, type='nms'),
            nms_pre=2000)),
    type='MaskRCNN')
optim_wrapper = dict(
    optimizer=dict(lr=0.02, momentum=0.9, type='SGD', weight_decay=0.0001),
    type='OptimWrapper')
param_scheduler = [
    dict(
        begin=0, by_epoch=False, end=500, start_factor=0.001, type='LinearLR'),
    dict(
        begin=0,
        by_epoch=True,
        end=12,
        gamma=0.1,
        milestones=[
            8,
            11,
        ],
        type='MultiStepLR'),
]
resume = False
test_cfg = dict(type='TestLoop')
test_dataloader = dict(
    batch_size=1,
    dataset=dict(
        ann_file='annotations/instances_val2017.json',
        backend_args=None,
        data_prefix=dict(img='val2017/'),
        data_root='data/coco/',
        pipeline=[
            dict(backend_args=None, type='LoadImageFromFile'),
            dict(keep_ratio=True, scale=(
                512,
                512,
            ), type='Resize'),
            dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
            dict(
                meta_keys=(
                    'img_id',
                    'img_path',
                    'ori_shape',
                    'img_shape',
                    'scale_factor',
                ),
                type='PackDetInputs'),
        ],
        test_mode=True,
        type='CocoDataset'),
    drop_last=False,
    num_workers=2,
    persistent_workers=True,
    sampler=dict(shuffle=False, type='DefaultSampler'))
test_evaluator = dict(
    ann_file='data/coco/annotations/instances_val2017.json',
    backend_args=None,
    format_only=False,
    metric=[
        'bbox',
        'segm',
    ],
    type='CocoMetric')
test_pipeline = [
    dict(backend_args=None, type='LoadImageFromFile'),
    dict(keep_ratio=True, scale=(
        512,
        512,
    ), type='Resize'),
    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
    dict(
        meta_keys=(
            'img_id',
            'img_path',
            'ori_shape',
            'img_shape',
            'scale_factor',
        ),
        type='PackDetInputs'),
]
train_cfg = dict(max_epochs=12, type='EpochBasedTrainLoop', val_interval=1)
train_dataloader = dict(
    batch_sampler=dict(type='AspectRatioBatchSampler'),
    batch_size=2,
    dataset=dict(
        ann_file='annotations/instances_train2017.json',
        backend_args=None,
        data_prefix=dict(img='train2017/'),
        data_root='data/coco/',
        filter_cfg=dict(filter_empty_gt=True, min_size=32),
        pipeline=[
            dict(backend_args=None, type='LoadImageFromFile'),
            dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
            dict(keep_ratio=True, scale=(
                512,
                512,
            ), type='Resize'),
            dict(prob=0.5, type='RandomFlip'),
            dict(type='PackDetInputs'),
        ],
        type='CocoDataset'),
    num_workers=2,
    persistent_workers=True,
    sampler=dict(shuffle=True, type='DefaultSampler'))
train_pipeline = [
    dict(backend_args=None, type='LoadImageFromFile'),
    dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
    dict(keep_ratio=True, scale=(
        512,
        512,
    ), type='Resize'),
    dict(prob=0.5, type='RandomFlip'),
    dict(type='PackDetInputs'),
]
val_cfg = dict(type='ValLoop')
val_dataloader = dict(
    batch_size=1,
    dataset=dict(
        ann_file='annotations/instances_val2017.json',
        backend_args=None,
        data_prefix=dict(img='val2017/'),
        data_root='data/coco/',
        pipeline=[
            dict(backend_args=None, type='LoadImageFromFile'),
            dict(keep_ratio=True, scale=(
                512,
                512,
            ), type='Resize'),
            dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
            dict(
                meta_keys=(
                    'img_id',
                    'img_path',
                    'ori_shape',
                    'img_shape',
                    'scale_factor',
                ),
                type='PackDetInputs'),
        ],
        test_mode=True,
        type='CocoDataset'),
    drop_last=False,
    num_workers=2,
    persistent_workers=True,
    sampler=dict(shuffle=False, type='DefaultSampler'))
val_evaluator = dict(
    ann_file='data/coco/annotations/instances_val2017.json',
    backend_args=None,
    format_only=False,
    metric=[
        'bbox',
        'segm',
    ],
    type='CocoMetric')
vis_backends = [
    dict(type='LocalVisBackend'),
]
visualizer = dict(
    name='visualizer',
    type='DetLocalVisualizer',
    vis_backends=[
        dict(type='LocalVisBackend'),
    ])
work_dir = 'major_test'

测试

python tools/test.py .\major_test\mask-rcnn_r50_fpn_1x_coco.py .\major_test\epoch_48.pth --show

在这里插入图片描述
在这里插入图片描述

Jumy_S
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【MMDetection3D实战(2)】: 利用MMDet3D预训练模型进行推理
@bangbang的博客
03-13 1565
图像和点云不太一样，点云自己一般比较难获取，图像会比较容易获取。如果希望在自己的图像上进行推理mmdet3D也是可以实现该功能的。总体代码和之前的是一样的，唯一的区别我们需要自己提供一个标注文件, 文件中主要是提供相机的内参。（1） 准备预训练权重模型文件之前已经下载好了，这边就不介绍了（2） 准备数据和标注文件图片image：网上找的街机游戏的图片标注文件ana：网上找的街机游戏的图片这个比较麻烦的是，我们需要获得该场景的相机参数，通常该参数我们是没有的。不过我们自己简单写一个。, 其中焦距。
【mmdetection】使用自定义的coco格式数据集进行训练及测试
YeeKo的博客
05-27 3万+
目录一、mmdetection简介二、环境安装1、安装教程2、运行demo测试环境是否安装成功三、训练自定义的dataset1、准备dataset2、Training前修改相关文件3、Training4、Testing 一、mmdetection简介 项目仓库地址：https://github.com/open-mmlab/mmdetection 香港中文大学-商汤科技联合实验室开源了基于 PyT...
mmdetect2d训练自己的数据集（二）—— 模型训练
onepunch_k的博客
03-25 1186
前言 近期在学习mmdetect，总体来说mmlab这个框架感觉上手难度还挺大的，自己也是结合b站各位up主（up主名称：我是土堆、OneShotLove、比飞鸟贵重的多_HKL）以及知乎mmlab官方边看边学，真的是保姆级教程，强烈推荐。但是大家为了防止以后忘记，记录一下，如果有不对的地方，欢迎大家批评指正。 关于数据前期处理请参照上一篇博客：mmdetect2d训练自己的数据集（一）—— labelme数据处理 一、 ...
【MMDetection系列 - 3】 MMdetection文件目录结构解析之mmdet文件（模型构建思想和流程）
最新发布
Fate_serendipity的博客
04-19 1893
本文主要分析mmdet文件目录结构中的mmdet文件，了解mmdetection整体构建流程、思想及其中各部分所完成的主要功能。（更新中）以上是对MMDetection文件目录结构的介绍，将在学习过程中不断进行完善。参考：[1][2]
MMDetection实战：MMDetection训练与测试
AI浩
05-08 1万+
摘要 MMDetection是商汤和港中文大学针对目标检测任务推出的一个开源项目，它基于Pytorch实现了大量的目标检测算法，把数据集构建、模型搭建、训练策略等过程都封装成了一个个模块，通过模块调用的方式，我们能够以很少的代码量实现一个新算法，大大提高了代码复用率。 GitHub链接：https://github.com/open-mmlab/mmdetection。 Gitee链接：https://gitee.com/open-mmlab/mmdetection。 主分支代码目前支持 PyTorch 1
mmdetection yolox-s TensorRT模型2060/2060s显卡可用
08-12
1. **模型导出**：首先，你需要用MMDetection训练好YOLOX-S模型，并将其导出为ONNX格式。MMDetection提供了方便的脚本来执行这个过程，通常涉及`tools/export.py`脚本的使用。 2. **TensorRT构建**：接下来，使用...
TensorRT-使用TensorRT部署mmdetection模型-支持fp16+int8+动态shape-优质部署项目
02-27
3. **模型验证**：在部署前，对转换后的模型进行验证，确保其预测结果与原始模型一致。 4. **优化和编译**：对模型进行优化，包括层融合、量化等，然后编译为可执行的引擎。 5. **推理服务**：最后，将编译好的...
基于 TensorFlow 开源的 object_detection 来训练自定义的 Mask R-CNN 模型.zip
03-28
在本文中，我们将深入探讨如何使用 TensorFlow 的开源项目 `object_detection` 来训练自定义的 Mask R-CNN 模型。Mask R-CNN 是一种强大的深度学习模型，它在对象检测的基础上增加了像素级别的分割功能，使得我们...
paddledetection，训练自己的数据集，并进行预测
11-11
在这个过程中，我们将讨论如何使用Paddledetection来训练自定义的数据集以及进行预测。 1. **Paddledetection的架构**： Paddledetection基于模块化设计，包括模型库、数据预处理、训练与评估、部署等核心模块。...
tensorflow物体识别object detection官方预训练模型
01-26
6. **部署**：训练完成后，将模型导出为可预测的格式，可以集成到应用程序或服务中，实现实时物体检测。 物体识别在许多领域都有应用，例如自动驾驶、安防监控、智能零售等。通过TensorFlow Object Detection API和...
MMDetection框架入门教程（完全版）
热门推荐
Sual
11-14 8万+
  网上MMDetection的教程看似有很多，但感觉都不成系统，看完一圈下来还是不知道MMDetection要怎么用。这里还是推荐直接跟着官方教程，结合源码学习MMDetection，相关链接汇总如下： 官方教程 - MMCV 官方教程 - MMDetection 官方教程 - 不得不知的 MMDetection 学习路线(个人经验版) 西安交大课件 - mmdetection教程(使用篇)   本文会介绍如何在MMDetection中从头开始搭建一套属于自己的算法。前几篇博客算是本人学习过...
detectron和mm-detection是干什么的？
weixin_33769207的博客
06-19 2414
1 背景介绍 mm-detection在功能上基本和Detectron一致，都是detection codebase（（视觉）检测代码库），而Detectron是世界上首个，所以先介绍下Detectron的诞生背景。 1.1 Detectron 是什么？ 2018年初，Facebook AI研究院(FAIR)公开了一个目标（视觉）检测平台，名叫Detectron。它是一个软件系统，由Pyth...
mmdetection
夏日山间过
08-02 3万+
概述 训练检测器的主要单元：数据加载、模型、迭代流水线。 数据加载 遵循典型约定，使用Dataset和Dataloader用于多个工作人员的数据加载。Dataset返回与模型的forward方法的参数对应的数据项的字典dict。由于对象检测中的数据可能不是相同的大小（图像大小，gt bbox大小等），所以引入一种新的DataContainer类型mmcv来帮助收集和分发不同大小的数据。 模型 ...
目标检测框架mmdetection框架的安装与测试
大数据挖掘SparkExpert的博客
03-06 1万+
最近利用Conda终于成功安装了mmdetection，说实话，非conda的还真的不好装，特别在.complie的时候，即使成功，总是会出现各种问题，直到conda安装后，才明白之前的问题关键所在，即必须numpy为1.16.2版本，且pytorch需要为1.0版本。之前从release版本中下载了0.4.1的版本，还是有问题。 1、框架介绍 这个框架还是非常清晰的，整个代码从骨架，模型，B...
mmdetection 源码解析——test.py
qq_31119477的博客
01-11 5099
一、程序结构 test.py的代码结构比较简单，如下流程图所示： １>1开始参数获取判断输出文件格式读取配置文件 (mmcv.Config.fromfile)设置cuda_benchmark, 模型，数据集判断gpu数量模型创建，数据加载单核输出模型创建，数据加载并行输出输出结果 核心代码梳理 (1)参数获取 args = parse_args() 主要解析参数，其参数含义为： ...
对象检测工具包mmdetection简介、安装及测试代码
网络资源是无限的
01-29 1万+
mmdetection是商汤和港中文大学联合开源的基于PyTorch的对象检测工具包，属于香港中文大学多媒体实验室open-mmlab项目的一部分。该工具包提供了已公开发表的多种流行的检测组件，通过这些组件的组合可以迅速搭建出各种检测框架。 mmdetection主要特性： (1). 模块化设计：可以通过连接不同组件容易地构建自定义的目标检测框架； (2). 支持多个流程检测框架：如RPN，...
MMDetection-简介
周先森爱吃素的博客
01-23 8459
本文对目标检测领域著名工具箱MMDetection进行基本介绍。
mmdetection训练模型怎么调用
08-10
要调用 mmdetection 训练的模型，你需要按照以下步骤进行操作： 1. 安装 mmdetection：按照官方文档的指导，安装 mmdetection 库并配置好相关环境。 2. 下载预训练的模型权重：在 mmdetection 的官方模型库（model zoo）中选择一个适合你任务的预训练模型，并下载相应的权重文件。 3. 配置模型参数：根据你的需求，在配置文件中设置模型的相关参数，如数据集路径、训练的超参数等。 4. 加载模型权重：使用 mmdetection 提供的 API，将下载的权重文件加载到模型中。 5. 进行推理或训练：根据你的需求，可以使用加载好权重的模型进行推理或者进一步进行训练。 具体的代码示例可以参考 mmdetection 的官方文档和示例代码，以便更好地理解和使用 mmdetection。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值