mmdet相关配置笔记

最新推荐文章于 2024-04-19 22:17:51 发布
最新推荐文章于 2024-04-19 22:17:51 发布
阅读量3.6k 收藏 6
点赞数 1
分类专栏： 笔记 文章标签： 笔记 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52799394/article/details/132669855
版权

目录

0.前言-版本选择

三步法：

1.创建虚拟环境与常用包

conda create -n mmdet python=3.7
conda activate mmdet

如果失败，重新安装虚拟环境相关代码：

conda env list					 	 查看虚拟环境列表
conda deactivate 					 关闭
conda remove -n mmdet --all			 删除虚拟环境
pip list/conda list 				 查看环境已安装包

pytorch1.8.1下载

pip install torch==1.8.1+cu111 torchvision==0.9.1+cu111 torchaudio==0.8.1 -f https://download.pytorch.org/whl/torch_stable.html

2.用openmin工具箱安装mmcv和mmdet

pip install -U openmim
mim install mmcv-full==1.6.2			# mmcv-full==1.6.2 版本明确对应

*若出现pip/conda安装pycocotools相关问题时：

conda install -c conda-forge pycocotools 			## 2.0.5

mim install mmdet==2.25.2				# mmdet==2.25.2	##版本明确对应
或文件夹下
pip install -v -e .

3.编译环境相关

pip install -r requirements/build.txt		# 编译环境
pip install -r requirements/optional.txt	
pip install -r requirements/runtime.txt
pip install -r requirements/tests.txt

pip install tensorboard

验证安装是否成功pip list，跑一个程序即可；

版本环境依据

在这里插入图片描述
在这里插入图片描述
Mmdet和RSI综合：ubuntu18.04；Cuda10.1；cudnn8.0.5；torch1.8.1；python3.7；但考虑到cuda向下兼容，最终环境选择如下：
ubuntu18.04；
Cuda11.1.1；
cudnn8.1.1；
torch1.8.1；
python3.7；

参考链接

RSI
Mmdet
mmdetection系列教程合集
4小时入门深度学习+实操MMDetection 第二课

1.qq安装

qq-linux官网下载程序，参考1.进击博客安装，方便截图写博客。
在这里插入图片描述

2.配置mmdet环境

版本回溯：
mmcv-full==1.6.2
mmdet == 2.25.2
在这里插入图片描述

2.1 安装配置（重要）

切换到对应虚拟环境；

conda activate mmdet

官方代码-install-best Practices

Step 0. Install MMCV using MIM(推荐)

MIM 能够自动地安装 OpenMMLab 的项目以及对应的依赖包！！！
mmcv类似于opencv的mmlab版；

pip install -U openmim
mim install mmcv-full

Step 1. Install MMDetection

Case a: If you develop and run mmdet directly, install it from source(推荐)

git clone https://github.com/open-mmlab/mmdetection.git
cd mmdetection
pip install -v -e .
# "-v" means verbose, or more output
# "-e" means installing a project in editable mode,
# thus any local modifications made to the code will take effect without reinstallation.

Case b: If you use mmdet as a dependency or third-party package, install it with pip:

# pip install mmdet
mim install mmdet

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

2.2 相关

在这里插入图片描述
如果已经安装了 mmcv，首先需要使用 pip uninstall mmcv 卸载已安装的 mmcv，如果同时安装了 mmcv 和 mmcv-full，将会报 ModuleNotFoundError 错误。

* 虚拟环境

配置好虚拟环境和torch对应版本后。继续安装后续mmcv和mmdet，注意二者之间的版本对应。
验证环境：cuda和pytorch版本
在这里插入图片描述

nvcc -V
import torch
print(torch.__version__)		# 1.8.1+cu111

* 安装mmcv

法1：使用预构建包来安装（实操安装出错）

需要把命令行中的 {cu_version} 和 {torch_version} 替换成对应的版本。pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/{cu_version}/{torch_version}/index.html

pip install mmcv-full -f https://download.openmmlab.com/mmcv/dist/cu111/torch1.8.1/index.html
法2：本地命令行从源码编译 MMCV

不推荐，说是对应安装，可能出错。

git clone https://github.com/open-mmlab/mmcv.git		## 或Download下载至对于目录
cd mmcv
MMCV_WITH_OPS=1 pip install -e .  # 安装好 mmcv-full
法3：Install MMCV using MIM

MIM 能够自动地安装 OpenMMLab 的项目以及对应的依赖包

pip install -U openmim
mim install mmcv-full

* 安装 MMDetection

法1：从 本地git 仓库编译源码

一些安装依赖是可以选择的。例如只需要安装最低运行要求的版本，则可以使用 pip install -v -e . 命令。不推荐。

git clone https://github.com/open-mmlab/mmdetection.git
cd mmdetection
# pip install -r requirements/build.txt
pip install -v -e .  # or "python setup.py develop"
# "-v" means verbose, or more output
# "-e" means installing a project in editable mode,
# thus any local modifications made to the code will take effect without reinstallation.
法2：命令从 pip 安装
# pip install mmdet
法3：自动安装 MMDetection（不推荐）

版本号不固定，对于易出现bug。

pip install openmim
## mim install mmdet
mim install mmdet==2.25.2		##不指定版本号默认最新易出现bug等

2.3 验证安装成功与否

1.py文件验证:测试

终端调用python
import mmdet
# !mim search mmdet --model maskrcnn   # terminal下载模型
# 验证版本是否安装成功
print(mmdet.__version__)

configs对应mask权重文件pth
faster.pth

python demo/image_demo.py demo/demo.jpg configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco.py checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco_bbox_mAP-0.403__segm_mAP-0.365_20200504_231822-a75c98ce.pth

2.测试2-检测

from mmdet.apis import init_detector,inference_detector,show_result_pyplot

config_file = "../configs/mask_rcnn/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco.py"
checkpoint_file = "../checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_2x_coco_bbox_mAP-0.403__segm_mAP-0.365_20200504_231822-a75c98ce.pth"
img = "../demo/demo.jpg"

model = init_detector(config_file,checkpoint_file)
result = inference_detector(model, img)
show_result_pyplot(model,img,result)

3.install environment

pip install -r requirements/build.txt
pip install -r requirements/optional.txt
pip install -r requirements/runtime.txt
pip install -r requirements/tests.txt

3.训练自定义模型数据

3.1 继承方式-config配置文件

1.修改模型（num_classes=1）；

原方法：configs -> _base_ -> model(mask_rcnn_50_fpn.py)

2.修改数据（dataset文件路径、裁剪大小、bs大小）；

原方法：configs -> _base_ -> datasets(coco.instance)

3.修改数据-类别 train/val/test->dict(classes=(‘pylon’)) 添加classes类

原方法：
mmdet -> core -> evaluation(class_names.py)  # return ['pylon']
mmdet -> datasets(coco.py)					 # classes = ['pylon']

_base_ = [
    '../configs/_base_/models/faster_rcnn_r50_fpn.py',
    '../configs/_base_/datasets/voc0712.py',
    '../configs/_base_/default_runtime.py'
]
# model = dict(roi_head=dict(bbox_head=dict(num_classes=1)))

# dataset settings
classes = ('pylon',)            # 数据类别
dataset_type = 'VOCDataset'
# data_root = 'data/VOCdevkit/'
data_root = 'add_data/'
img_norm_cfg = dict(
    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)   # 像素归一化均值和标准差
train_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(type='LoadAnnotations', with_bbox=True),
    dict(type='Resize', img_scale=(1000, 600), keep_ratio=True),
    dict(type='RandomFlip', flip_ratio=0.5),
    dict(type='Normalize', **img_norm_cfg),
    dict(type='Pad', size_divisor=32),
    dict(type='DefaultFormatBundle'),
    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
]
test_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(
        type='MultiScaleFlipAug',
        img_scale=(1000, 600),
        flip=False,
        transforms=[
            dict(type='Resize', keep_ratio=True),
            dict(type='RandomFlip'),
            dict(type='Normalize', **img_norm_cfg),
            dict(type='Pad', size_divisor=32),
            dict(type='ImageToTensor', keys=['img']),
            dict(type='Collect', keys=['img']),
        ])
]
data = dict(
    samples_per_gpu=2,                      # 配置batch-size
    workers_per_gpu=2,                      # 配置Dataloader进程数
    train=dict(
        type='RepeatDataset',
        times=3,                            # 数据重复3遍
        dataset=dict(
            type=dataset_type,
            # ann_file=[
            #     data_root + 'VOC2007/ImageSets/Main/trainval.txt',
            #     data_root + 'VOC2012/ImageSets/Main/trainval.txt'
            # ],
            # img_prefix=[data_root + 'VOC2007/', data_root + 'VOC2012/'],
            ann_file=[
                data_root + 'VOC2007/ImageSets/Main/trainval.txt'
            ],
            img_prefix=[data_root + 'VOC2007/'],
            classes = classes,
            pipeline=train_pipeline)),                                  # 数据处理流水线pipeline
    val=dict(
        type=dataset_type,
        ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt',
        img_prefix=data_root + 'VOC2007/',
        # ann_file=data_root + 'ImageSets/Main/test.txt',
        # img_prefix=data_root,
        classes = classes,
        pipeline=test_pipeline),
    test=dict(
        type=dataset_type,
        ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt',
        img_prefix=data_root + 'VOC2007/',
        # ann_file=data_root + 'ImageSets/Main/test.txt',
        # img_prefix=data_root,
        classes = classes,
        pipeline=test_pipeline))
evaluation = dict(interval=1, metric='mAP')                             # 每x回合评估map

checkpoint_config = dict(interval=1)                                    # 每x回合保存权重文件

model = dict(roi_head=dict(bbox_head=dict(num_classes=1)))              # 数据集类别数
load_from = "checkpoints/faster_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.378_20200504_180032-c5925ee5.pth"
# epoch
runner = dict(
    type='EpochBasedRunner', max_epochs=4)  # actual epoch = 4 * 3 = 12 - # 数据重复3遍；回合数
# learning-rate
optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
optimizer_config = dict(grad_clip=None)                                   # 高级配置，暂默认
lr_config = dict(policy='step', step=[3])                                 # 控制学习率
# logging
log_config = dict(interval=50,hooks=[
        # dict(type='TensorboardLoggerHook')  # 同样支持 Tensorboard 日志
        dict(type='TextLoggerHook')
    ])                                                                    # 每x个迭代次数保存一次日志

work_dir = 'testdir'                                                      # 文件存储输出路径
# gpu_ids = range(0, 1)                                                   # 使用gpu数？删除中文注释，否则gbk报错


# # optimizer
# optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)          # learning-rate
# optimizer_config = dict(grad_clip=None)
# # learning policy
# # actual epoch = 3 * 3 = 9
# lr_config = dict(policy='step', step=[3])                                         # 控制学习率
# # runtime settings
# runner = dict(
#     type='EpochBasedRunner', max_epochs=4)  # actual epoch = 4 * 3 = 12           # epoch

在这里插入图片描述

3.2 启动

1.py文件验证：测试1

from mmcv import Config

## 测试配置文件继承是否生效
config = Config.fromfile('./faster_rcnn_r50_fpn_1x_voc.py')		# 自定义配置文件路径 model+data+optimizer
print(config.pretty_text)

2.终端开启，使用ctrl+c终止

## 测试训练-colab终端运行部分
## !mim train mmdet fruit.py
python tools/train.py add_myexperiment/faster_rcnn_r50_fpn_1x_voc.py --gpus 1 --work-dir testdir

3.3 官网相关注释

model = dict(
    type='MaskRCNN',  # 检测器(detector)名称
    backbone=dict(  # 主干网络的配置文件
        type='ResNet',  # 主干网络的类别，可用选项请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/backbones/resnet.py#L308
        depth=50,  # 主干网络的深度，对于 ResNet 和 ResNext 通常设置为 50 或 101。
        num_stages=4,  # 主干网络状态(stages)的数目，这些状态产生的特征图作为后续的 head 的输入。
        out_indices=(0, 1, 2, 3),  # 每个状态产生的特征图输出的索引。
        frozen_stages=1,  # 第一个状态的权重被冻结
        norm_cfg=dict(  # 归一化层(norm layer)的配置项。
            type='BN',  # 归一化层的类别，通常是 BN 或 GN。
            requires_grad=True),  # 是否训练归一化里的 gamma 和 beta。
        norm_eval=True,  # 是否冻结 BN 里的统计项。
        style='pytorch',  # 主干网络的风格，'pytorch' 意思是步长为2的层为 3x3 卷积， 'caffe' 意思是步长为2的层为 1x1 卷积。
       init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),  # 加载通过 ImageNet 预训练的模型
    neck=dict(
        type='FPN',  # 检测器的 neck 是 FPN，我们同样支持 'NASFPN', 'PAFPN' 等，更多细节可以参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/necks/fpn.py#L10。
        in_channels=[256, 512, 1024, 2048],  # 输入通道数，这与主干网络的输出通道一致
        out_channels=256,  # 金字塔特征图每一层的输出通道
        num_outs=5),  # 输出的范围(scales)
    rpn_head=dict(
        type='RPNHead',  # RPN_head 的类型是 'RPNHead', 我们也支持 'GARPNHead' 等，更多细节可以参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/dense_heads/rpn_head.py#L12。
        in_channels=256,  # 每个输入特征图的输入通道，这与 neck 的输出通道一致。
        feat_channels=256,  # head 卷积层的特征通道。
        anchor_generator=dict(  # 锚点(Anchor)生成器的配置。
            type='AnchorGenerator',  # 大多是方法使用 AnchorGenerator 作为锚点生成器, SSD 检测器使用 `SSDAnchorGenerator`。更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/core/anchor/anchor_generator.py#L10。
            scales=[8],  # 锚点的基本比例，特征图某一位置的锚点面积为 scale * base_sizes
            ratios=[0.5, 1.0, 2.0],  # 高度和宽度之间的比率。
            strides=[4, 8, 16, 32, 64]),  # 锚生成器的步幅。这与 FPN 特征步幅一致。 如果未设置 base_sizes，则当前步幅值将被视为 base_sizes。
        bbox_coder=dict(  # 在训练和测试期间对框进行编码和解码。
            type='DeltaXYWHBBoxCoder',  # 框编码器的类别，'DeltaXYWHBBoxCoder' 是最常用的，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/core/bbox/coder/delta_xywh_bbox_coder.py#L9。
            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',  # 分类分支的损失类型，我们也支持 FocalLoss 等。
            use_sigmoid=True,  # RPN通常进行二分类，所以通常使用sigmoid函数。
            los_weight=1.0),  # 分类分支的损失权重。
        loss_bbox=dict(  # 回归分支的损失函数配置。
            type='L1Loss',  # 损失类型，我们还支持许多 IoU Losses 和 Smooth L1-loss 等，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/losses/smooth_l1_loss.py#L56。
            loss_weight=1.0)),  # 回归分支的损失权重。
    roi_head=dict(  # RoIHead 封装了两步(two-stage)/级联(cascade)检测器的第二步。
        type='StandardRoIHead',  # RoI head 的类型，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/roi_heads/standard_roi_head.py#L10。
        bbox_roi_extractor=dict(  # 用于 bbox 回归的 RoI 特征提取器。
            type='SingleRoIExtractor',  # RoI 特征提取器的类型，大多数方法使用  SingleRoIExtractor，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/roi_heads/roi_extractors/single_level.py#L10。
            roi_layer=dict(  # RoI 层的配置
                type='RoIAlign',  # RoI 层的类别, 也支持 DeformRoIPoolingPack 和 ModulatedDeformRoIPoolingPack，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/ops/roi_align/roi_align.py#L79。
                output_size=7,  # 特征图的输出大小。
                sampling_ratio=0),  # 提取 RoI 特征时的采样率。0 表示自适应比率。
            out_channels=256,  # 提取特征的输出通道。
            featmap_strides=[4, 8, 16, 32]),  # 多尺度特征图的步幅，应该与主干的架构保持一致。
        bbox_head=dict(  # RoIHead 中 box head 的配置.
            type='Shared2FCBBoxHead',  # bbox head 的类别，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/roi_heads/bbox_heads/convfc_bbox_head.py#L177。
            in_channels=256,  # bbox head 的输入通道。 这与 roi_extractor 中的 out_channels 一致。
            fc_out_channels=1024,  # FC 层的输出特征通道。
            roi_feat_size=7,  # 候选区域(Region of Interest)特征的大小。
            num_classes=80,  # 分类的类别数量。
            bbox_coder=dict(  # 第二阶段使用的框编码器。
                type='DeltaXYWHBBoxCoder',  # 框编码器的类别，大多数情况使用 'DeltaXYWHBBoxCoder'。
                target_means=[0.0, 0.0, 0.0, 0.0],  # 用于编码和解码框的均值
                target_stds=[0.1, 0.1, 0.2, 0.2]),  # 编码和解码的标准差。因为框更准确，所以值更小，常规设置时 [0.1, 0.1, 0.2, 0.2]。
            reg_class_agnostic=False,  # 回归是否与类别无关。
            loss_cls=dict(  # 分类分支的损失函数配置
                type='CrossEntropyLoss',  # 分类分支的损失类型，我们也支持 FocalLoss 等。
                use_sigmoid=False,  # 是否使用 sigmoid。
                loss_weight=1.0),  # 分类分支的损失权重。
            loss_bbox=dict(  # 回归分支的损失函数配置。
                type='L1Loss',  # 损失类型，我们还支持许多 IoU Losses 和 Smooth L1-loss 等。
                loss_weight=1.0)),  # 回归分支的损失权重。
        mask_roi_extractor=dict(  # 用于 mask 生成的 RoI 特征提取器。
            type='SingleRoIExtractor',  # RoI 特征提取器的类型，大多数方法使用 SingleRoIExtractor。
            roi_layer=dict(  # 提取实例分割特征的 RoI 层配置
                type='RoIAlign',  # RoI 层的类型，也支持 DeformRoIPoolingPack 和 ModulatedDeformRoIPoolingPack。
                output_size=14,  # 特征图的输出大小。
                sampling_ratio=0),  # 提取 RoI 特征时的采样率。
            out_channels=256,  # 提取特征的输出通道。
            featmap_strides=[4, 8, 16, 32]),  # 多尺度特征图的步幅。
        mask_head=dict(  # mask 预测 head 模型
            type='FCNMaskHead',  # mask head 的类型，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/roi_heads/mask_heads/fcn_mask_head.py#L21。
            num_convs=4,  # mask head 中的卷积层数
            in_channels=256,  # 输入通道，应与 mask roi extractor 的输出通道一致。
            conv_out_channels=256,  # 卷积层的输出通道。
            num_classes=80,  # 要分割的类别数。
            loss_mask=dict(  # mask 分支的损失函数配置。
                type='CrossEntropyLoss',  # 用于分割的损失类型。
                use_mask=True,  # 是否只在正确的类中训练 mask。
                loss_weight=1.0))))  # mask 分支的损失权重.
    train_cfg = dict(  # rpn 和 rcnn 训练超参数的配置
        rpn=dict(  # rpn 的训练配置
            assigner=dict(  # 分配器(assigner)的配置
                type='MaxIoUAssigner',  # 分配器的类型，MaxIoUAssigner 用于许多常见的检测器，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/core/bbox/assigners/max_iou_assigner.py#L10。
                pos_iou_thr=0.7,  # IoU >= 0.7(阈值) 被视为正样本。
                neg_iou_thr=0.3,  # IoU < 0.3(阈值) 被视为负样本。
                min_pos_iou=0.3,  # 将框作为正样本的最小 IoU 阈值。
                match_low_quality=True,  # 是否匹配低质量的框(更多细节见 API 文档).
                ignore_iof_thr=-1),  # 忽略 bbox 的 IoF 阈值。
            sampler=dict(  # 正/负采样器(sampler)的配置
                type='RandomSampler',  # 采样器类型，还支持 PseudoSampler 和其他采样器，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/core/bbox/samplers/random_sampler.py#L8。
                num=256,  # 样本数量。
                pos_fraction=0.5,  # 正样本占总样本的比例。
                neg_pos_ub=-1,  # 基于正样本数量的负样本上限。
                add_gt_as_proposals=False),  # 采样后是否添加 GT 作为 proposal。
            allowed_border=-1,  # 填充有效锚点后允许的边框。
            pos_weight=-1,  # 训练期间正样本的权重。
            debug=False),  # 是否设置调试(debug)模式
        rpn_proposal=dict(  # 在训练期间生成 proposals 的配置
            nms_across_levels=False,  # 是否对跨层的 box 做 NMS。仅适用于 `GARPNHead` ，naive rpn 不支持 nms cross levels。
            nms_pre=2000,  # NMS 前的 box 数
            nms_post=1000,  # NMS 要保留的 box 的数量，只在 GARPNHHead 中起作用。
            max_per_img=1000,  # NMS 后要保留的 box 数量。
            nms=dict( # NMS 的配置
                type='nms',  # NMS 的类别
                iou_threshold=0.7 # NMS 的阈值
                ),
            min_bbox_size=0),  # 允许的最小 box 尺寸
        rcnn=dict(  # roi head 的配置。
            assigner=dict(  # 第二阶段分配器的配置，这与 rpn 中的不同
                type='MaxIoUAssigner',  # 分配器的类型，MaxIoUAssigner 目前用于所有 roi_heads。更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/core/bbox/assigners/max_iou_assigner.py#L10。
                pos_iou_thr=0.5,  # IoU >= 0.5(阈值)被认为是正样本。
                neg_iou_thr=0.5,  # IoU < 0.5(阈值)被认为是负样本。
                min_pos_iou=0.5,  # 将 box 作为正样本的最小 IoU 阈值
                match_low_quality=False,  # 是否匹配低质量下的 box(有关更多详细信息，请参阅 API 文档)。
                ignore_iof_thr=-1),  # 忽略 bbox 的 IoF 阈值
            sampler=dict(
                type='RandomSampler',  #采样器的类型，还支持 PseudoSampler 和其他采样器，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/core/bbox/samplers/random_sampler.py#L8。
                num=512,  # 样本数量
                pos_fraction=0.25,  # 正样本占总样本的比例。.
                neg_pos_ub=-1,  # 基于正样本数量的负样本上限。.
                add_gt_as_proposals=True
            ),  # 采样后是否添加 GT 作为 proposal。
            mask_size=28,  # mask 的大小
            pos_weight=-1,  # 训练期间正样本的权重。
            debug=False))  # 是否设置调试模式。
    test_cfg = dict(  # 用于测试 rpn 和 rcnn 超参数的配置
        rpn=dict(  # 测试阶段生成 proposals 的配置
            nms_across_levels=False,  # 是否对跨层的 box 做 NMS。仅适用于`GARPNHead`，naive rpn 不支持做 NMS cross levels。
            nms_pre=1000,  # NMS 前的 box 数
            nms_post=1000,  # NMS 要保留的 box 的数量，只在`GARPNHHead`中起作用。
            max_per_img=1000,  # NMS 后要保留的 box 数量
            nms=dict( # NMS 的配置
                type='nms',  # NMS 的类型
                iou_threshold=0.7 # NMS 阈值
                ),
            min_bbox_size=0),  # box 允许的最小尺寸
        rcnn=dict(  # roi heads 的配置
            score_thr=0.05,  # bbox 的分数阈值
            nms=dict(  # 第二步的 NMS 配置
                type='nms',  # NMS 的类型
                iou_thr=0.5),  # NMS 的阈值
            max_per_img=100,  # 每张图像的最大检测次数
            mask_thr_binary=0.5))  # mask 预处的阈值
dataset_type = 'CocoDataset'  # 数据集类型，这将被用来定义数据集。
data_root = 'data/coco/'  # 数据的根路径。
img_norm_cfg = dict(  # 图像归一化配置，用来归一化输入的图像。
    mean=[123.675, 116.28, 103.53],  # 预训练里用于预训练主干网络模型的平均值。
    std=[58.395, 57.12, 57.375],  # 预训练里用于预训练主干网络模型的标准差。
    to_rgb=True
)  #  预训练里用于预训练主干网络的图像的通道顺序。
train_pipeline = [  # 训练流程
    dict(type='LoadImageFromFile'),  # 第 1 个流程，从文件路径里加载图像。
    dict(
        type='LoadAnnotations',  # 第 2 个流程，对于当前图像，加载它的注释信息。
        with_bbox=True,  # 是否使用标注框(bounding box)， 目标检测需要设置为 True。
        with_mask=True,  # 是否使用 instance mask，实例分割需要设置为 True。
        poly2mask=False),  # 是否将 polygon mask 转化为 instance mask, 设置为 False 以加速和节省内存。
    dict(
        type='Resize',  # 变化图像和其注释大小的数据增广的流程。
        img_scale=(1333, 800),  # 图像的最大规模。
        keep_ratio=True
    ),  # 是否保持图像的长宽比。
    dict(
        type='RandomFlip',  #  翻转图像和其注释大小的数据增广的流程。
        flip_ratio=0.5),  # 翻转图像的概率。
    dict(
        type='Normalize',  # 归一化当前图像的数据增广的流程。
        mean=[123.675, 116.28, 103.53],  # 这些键与 img_norm_cfg 一致，因为 img_norm_cfg 被
        std=[58.395, 57.12, 57.375],     # 用作参数。
        to_rgb=True),
    dict(
        type='Pad',  # 填充当前图像到指定大小的数据增广的流程。
        size_divisor=32),  # 填充图像可以被当前值整除。
    dict(type='DefaultFormatBundle'),  # 流程里收集数据的默认格式捆。
    dict(
        type='Collect',  # 决定数据中哪些键应该传递给检测器的流程
        keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks'])
]
test_pipeline = [
    dict(type='LoadImageFromFile'),  # 第 1 个流程，从文件路径里加载图像。
    dict(
        type='MultiScaleFlipAug',  # 封装测试时数据增广(test time augmentations)。
        img_scale=(1333, 800),  # 决定测试时可改变图像的最大规模。用于改变图像大小的流程。
        flip=False,  # 测试时是否翻转图像。
        transforms=[
            dict(type='Resize',  # 使用改变图像大小的数据增广。
                 keep_ratio=True),  # 是否保持宽和高的比例，这里的图像比例设置将覆盖上面的图像规模大小的设置。
            dict(type='RandomFlip'),  # 考虑到 RandomFlip 已经被添加到流程里，当 flip=False 时它将不被使用。
            dict(
                type='Normalize',  #  归一化配置项，值来自 img_norm_cfg。
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(
                type='Pad',  # 将配置传递给可被 32 整除的图像。
                size_divisor=32),
            dict(
                type='ImageToTensor',  # 将图像转为张量
                keys=['img']),
            dict(
                type='Collect',  # 收集测试时必须的键的收集流程。
                keys=['img'])
        ])
]
data = dict(
    samples_per_gpu=2,  # 单个 GPU 的 Batch size
    workers_per_gpu=2,  # 单个 GPU 分配的数据加载线程数
    train=dict(  # 训练数据集配置
        type='CocoDataset',  # 数据集的类别, 更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/datasets/coco.py#L19。
        ann_file='data/coco/annotations/instances_train2017.json',  # 注释文件路径
        img_prefix='data/coco/train2017/',  # 图片路径前缀
        pipeline=[  # 流程, 这是由之前创建的 train_pipeline 传递的。
            dict(type='LoadImageFromFile'),
            dict(
                type='LoadAnnotations',
                with_bbox=True,
                with_mask=True,
                poly2mask=False),
            dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
            dict(type='RandomFlip', flip_ratio=0.5),
            dict(
                type='Normalize',
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(type='Pad', size_divisor=32),
            dict(type='DefaultFormatBundle'),
            dict(
                type='Collect',
                keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks'])
        ]),
    val=dict(  # 验证数据集的配置
        type='CocoDataset',
        ann_file='data/coco/annotations/instances_val2017.json',
        img_prefix='data/coco/val2017/',
        pipeline=[  # 由之前创建的 test_pipeline 传递的流程。
            dict(type='LoadImageFromFile'),
            dict(
                type='MultiScaleFlipAug',
                img_scale=(1333, 800),
                flip=False,
                transforms=[
                    dict(type='Resize', keep_ratio=True),
                    dict(type='RandomFlip'),
                    dict(
                        type='Normalize',
                        mean=[123.675, 116.28, 103.53],
                        std=[58.395, 57.12, 57.375],
                        to_rgb=True),
                    dict(type='Pad', size_divisor=32),
                    dict(type='ImageToTensor', keys=['img']),
                    dict(type='Collect', keys=['img'])
                ])
        ]),
    test=dict(  # 测试数据集配置，修改测试开发/测试(test-dev/test)提交的 ann_file
        type='CocoDataset',
        ann_file='data/coco/annotations/instances_val2017.json',
        img_prefix='data/coco/val2017/',
        pipeline=[  # 由之前创建的 test_pipeline 传递的流程。
            dict(type='LoadImageFromFile'),
            dict(
                type='MultiScaleFlipAug',
                img_scale=(1333, 800),
                flip=False,
                transforms=[
                    dict(type='Resize', keep_ratio=True),
                    dict(type='RandomFlip'),
                    dict(
                        type='Normalize',
                        mean=[123.675, 116.28, 103.53],
                        std=[58.395, 57.12, 57.375],
                        to_rgb=True),
                    dict(type='Pad', size_divisor=32),
                    dict(type='ImageToTensor', keys=['img']),
                    dict(type='Collect', keys=['img'])
                ])
        ],
        samples_per_gpu=2  # 单个 GPU 测试时的 Batch size
        ))
evaluation = dict(  # evaluation hook 的配置，更多细节请参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/core/evaluation/eval_hooks.py#L7。
    interval=1,  # 验证的间隔。
    metric=['bbox', 'segm'])  # 验证期间使用的指标。
optimizer = dict(  # 用于构建优化器的配置文件。支持 PyTorch 中的所有优化器，同时它们的参数与 PyTorch 里的优化器参数一致。
    type='SGD',  # 优化器种类，更多细节可参考 https://github.com/open-mmlab/mmdetection/blob/master/mmdet/core/optimizer/default_constructor.py#L13。
    lr=0.02,  # 优化器的学习率，参数的使用细节请参照对应的 PyTorch 文档。
    momentum=0.9,  # 动量(Momentum)
    weight_decay=0.0001)  # SGD 的衰减权重(weight decay)。
optimizer_config = dict(  # optimizer hook 的配置文件，执行细节请参考 https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/hooks/optimizer.py#L8。
    grad_clip=None)  # 大多数方法不使用梯度限制(grad_clip)。
lr_config = dict(  # 学习率调整配置，用于注册 LrUpdater hook。
    policy='step',  # 调度流程(scheduler)的策略，也支持 CosineAnnealing, Cyclic, 等。请从 https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/hooks/lr_updater.py#L9 参考 LrUpdater 的细节。
    warmup='linear',  # 预热(warmup)策略，也支持 `exp` 和 `constant`。
    warmup_iters=500,  # 预热的迭代次数
    warmup_ratio=
    0.001,  # 用于热身的起始学习率的比率
    step=[8, 11])  # 衰减学习率的起止回合数
runner = dict(
    type='EpochBasedRunner',  # 将使用的 runner 的类别 (例如 IterBasedRunner 或 EpochBasedRunner)。
    max_epochs=12) # runner 总回合数， 对于 IterBasedRunner 使用 `max_iters`
checkpoint_config = dict(  # Checkpoint hook 的配置文件。执行时请参考 https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/hooks/checkpoint.py。
    interval=1)  # 保存的间隔是 1。
log_config = dict(  # register logger hook 的配置文件。
    interval=50,  # 打印日志的间隔
    hooks=[
        # dict(type='TensorboardLoggerHook')  # 同样支持 Tensorboard 日志
        dict(type='TextLoggerHook')
    ])  # 用于记录训练过程的记录器(logger)。
dist_params = dict(backend='nccl')  # 用于设置分布式训练的参数，端口也同样可被设置。
log_level = 'INFO'  # 日志的级别。
load_from = None  # 从一个给定路径里加载模型作为预训练模型，它并不会消耗训练时间。
resume_from = None  # 从给定路径里恢复检查点(checkpoints)，训练模式将从检查点保存的轮次开始恢复训练。
workflow = [('train', 1)]  # runner 的工作流程，[('train', 1)] 表示只有一个工作流且工作流仅执行一次。根据 total_epochs 工作流训练 12个回合。
work_dir = 'work_dir'  # 用于保存当前实验的模型检查点和日志的目录。

运行

_base_ = [
    '../configs/_base_/models/faster_rcnn_r50_fpn.py',
    '../configs/_base_/datasets/voc0712.py',
    '../configs/_base_/default_runtime.py'
]
# model = dict(roi_head=dict(bbox_head=dict(num_classes=1)))

# dataset settings
classes = ('pylon',)            # data class - E:\workE_py\mmdetection-master\mmdet\core\evaluation\class_names.py -> return ['pylon']
dataset_type = 'VOCDataset'
# data_root = 'data/VOCdevkit/'
data_root = 'add_data/'
img_norm_cfg = dict(
    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)   # normal
train_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(type='LoadAnnotations', with_bbox=True),
    dict(type='Resize', img_scale=(1000, 600), keep_ratio=True),
    dict(type='RandomFlip', flip_ratio=0.5),
    dict(type='Normalize', **img_norm_cfg),
    dict(type='Pad', size_divisor=32),
    dict(type='DefaultFormatBundle'),
    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
]
test_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(
        type='MultiScaleFlipAug',
        img_scale=(1000, 600),
        flip=False,
        transforms=[
            dict(type='Resize', keep_ratio=True),
            dict(type='RandomFlip'),
            dict(type='Normalize', **img_norm_cfg),
            dict(type='Pad', size_divisor=32),
            dict(type='ImageToTensor', keys=['img']),
            dict(type='Collect', keys=['img']),
        ])
]
data = dict(
    samples_per_gpu=8,                      # batch-size
    workers_per_gpu=4,                      # Dataloader
    train=dict(
        type='RepeatDataset',
        # times=3,                            # data repeat time=3
        times=2,                            # data repeat time=1
        dataset=dict(
            type=dataset_type,
            # ann_file=[
            #     data_root + 'VOC2007/ImageSets/Main/trainval.txt',
            #     data_root + 'VOC2012/ImageSets/Main/trainval.txt'
            # ],
            # img_prefix=[data_root + 'VOC2007/', data_root + 'VOC2012/'],
            ann_file=[
                data_root + 'VOC2007/ImageSets/Main/trainval.txt'
            ],
            img_prefix=[data_root + 'VOC2007/'],
            classes = classes,
            pipeline=train_pipeline)),                                  # data pipeline
    val=dict(
        type=dataset_type,
        ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt',
        img_prefix=data_root + 'VOC2007/',
        # ann_file=data_root + 'ImageSets/Main/test.txt',
        # img_prefix=data_root,
        classes = classes,
        pipeline=test_pipeline),
    test=dict(
        type=dataset_type,
        ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt',
        img_prefix=data_root + 'VOC2007/',
        # ann_file=data_root + 'ImageSets/Main/test.txt',
        # img_prefix=data_root,
        classes = classes,
        pipeline=test_pipeline))
evaluation = dict(interval=1, metric='mAP')                             # x epoch map
checkpoint_config = dict(interval=1)                                    # x epoch pth

model = dict(roi_head=dict(bbox_head=dict(num_classes=1)))              # dataset class number
load_from = "checkpoints/faster_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.378_20200504_180032-c5925ee5.pth"
# epoch
runner = dict(
    type='EpochBasedRunner', max_epochs=2)  # actual epoch = 4 * 3 = 12 - # data repeat time=3
# learning-rate
optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
optimizer_config = dict(grad_clip=None)                                   # default
lr_config = dict(policy='step', step=[3])                                 # control lr
# logging
log_config = dict(interval=50,hooks=[
        # dict(type='TensorboardLoggerHook')  #Tensorboard
        dict(type='TextLoggerHook')
    ])
# log_config = dict(interval=100,hooks=[
#         # dict(type='TensorboardLoggerHook')  #Tensorboard
#         dict(type='TextLoggerHook')
#     ])                                                                    # x itera

work_dir = 'testdir'
gpu_ids = range(0, 1)


# # optimizer
# optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)          # learning-rate
# optimizer_config = dict(grad_clip=None)
# # learning policy
# # actual epoch = 3 * 3 = 9
# lr_config = dict(policy='step', step=[3])
# # runtime settings
# runner = dict(
#     type='EpochBasedRunner', max_epochs=4)  # actual epoch = 4 * 3 = 12           # epoch

参考链接

mmdet官方配置文件中文教程
官方相关视频

vancefeng
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MMdet 网络集简介
一碗白开水一
11-02 7883
mmdet网络简介： [RPN]：采用select-search的方法生成候选框，并将每个候选框送入网络，并做分类，其计算量大。 [Fast R-CNN]：在RPNj基础上引入ROI pooling算法。 [Faster R-CNN]：在Fast-rcc基础上引入RPN算法。 [Mask R-CNN]：在 Faster R-CNN基础上引入ROI-aliment算法。 [Cascade R-CNN]： 采用了Cascade的骨架模型，使算法更高效。 [Cascade Mask R-CNN]：融
有道云笔记护眼配置
05-08
有道云笔记修改护眼绿背景色，有时候如果电脑一直是白色的话，对眼睛不好，所以要改成护眼的颜色
mmdet cpu版安装
DreamLike_zzg的博客
06-03 1441
conda create -n open-mmlab python=3.6 conda activate open-mmlab conda install pytorch=1.3.1 torchvision=0.4.2 cpuonly -c pytorch pip install cython=0.29.19 git clone https://github.com/cocodataset/cocoapi.git cd cocoapi/PythonAPI make cd ../.. python c.
mmdet 实践
m0_54824511的博客
02-07 166
2023.2.7 openmmlab ai训练营直播内容笔记
mmdet阅读-paper(SSD)
u010848594的博客
07-26 189
SSD: Single Shot MultiBox Detector 原理：SSD的核心，对于feature map上每一个格子(cell)，生成多个default box，然后利用small convolutional filters 预测盒子偏移量和分类。 创新点：多尺度预测，因为模型感受野不同，小目标放在浅层预测，大目标放在后层预测 Pipeline： 首先用VGG16做特征提取，得到特征feats ...
超越所有YOLO检测模型，mmdet开源当今最强最快目标检测模型！
weixin_40920183的博客
09-26 6343
首先，这里先声明一下由于论文和代码没有一并放出，所以以下内容全是个人学习RTMDet代码的一个结果，整个过程时间也比较紧凑，难免会有所遗漏和错误，一切关于RTMDet的工作，最终以OpenMMLab官方论文为主，因为看到开源代码的速度表，小编很难不爱，小模型就可以把YOLO全系列按在地上摩擦，因此也就有了下面的故事。0、直接上架构图吧！看着上面的图，熟悉不？是不是满满的YOLO系列的味道？是的，看...
DB2安装配置学习笔记.doc
02-21
DB2 安装配置学习笔记 DB2 安装配置学习笔记是一份关于 DB2 在 Unix 或 Linux 上的安装配置的学习笔记，涵盖...通过本学习笔记，读者可以了解 DB2 在 Unix 或 Linux 上的安装配置过程，并掌握相关的知识点和注意事项。
VPS 配置优化笔记
09-16
VPS（Virtual Private Server 虚拟专用服务器）技术，将一部服务器分割成多个虚拟专享服务器的优质服务。每个VPS都可分配独立公网IP地址、独立操作系统、独立超大空间、独立内存、独立执行程序和独立系统配置等。
PhpStorm Xampp ThinkPHP 环境配置笔记
06-14
这篇笔记主要讲述了如何在Windows环境下配置一个用于开发ThinkPHP项目的集成环境，包括XAMPP、PhpStorm和ThinkPHP的设置。下面将详细讲解每个步骤： 首先，我们需要安装XAMPP，这是一个包含Apache服务器、MySQL...
PCL——Kinfu配置成功笔记
02-11
这篇笔记将详细讲述如何成功配置PCL的Kinfu功能，帮助开发者省去摸索的时间。 首先，确保你已经安装了PCL的基本环境。PCL通常依赖于一系列库，包括但不限于OpenCV、Boost、Qt、FLANN、Eigen、VTK等。你可以通过包...
写给萌新的mmdet
weixin_46587777的博客
06-01 828
mmcv
mmdet框架理解
ydestspring的博客
02-16 740
mmdet框架顶层简易理解。
【MMDetection系列 - 3】 MMdetection文件目录结构解析之mmdet文件（模型构建思想和流程）
最新发布
Fate_serendipity的博客
04-19 1920
本文主要分析mmdet文件目录结构中的mmdet文件，了解mmdetection整体构建流程、思想及其中各部分所完成的主要功能。（更新中）以上是对MMDetection文件目录结构的介绍，将在学习过程中不断进行完善。参考：[1][2]
win10下使用mmdet训练自己的数据模型
weixin_38226321的博客
08-24 2144
win10下使用mmdet训练自己的数据模型1.环境配置2.制作自己的coco数据集3.进行训练 1.环境配置 1.查看自己cuda版本： 2.查看自己python版本 3.安装pytorch 官方地址，按自己的选择复制粘贴到自己的python虚拟环境中。安装完之后在自己的虚拟环境中打开python，输入import torch，如果没有报错，说明自己的pytorch安装成功。 4.安装mmcv和mmdet 在自己虚拟环境中输入pip install mmcv（或者pip install mmcv-fu
mmdet代码复现：安装指定版本的mmcv和mmdet以及版本匹配问题。
热门推荐
shysea2019的博客
03-28 1万+
目标检测，复现论文，mmdetection框架，mmcv-，环境搭建
MMDet 3.0：目标检测新基准与前沿
qq_39967751的博客
10-21 2882
** 基于全新的训练引擎 MMEngine，MMDetection 3.0 和其它 OpenMMLab 2.0 的算法库彻底拉通了底层设计，并采用了统一的细粒度抽象与接口，使得训练流程更加灵活，架构更具扩展性。在此基础上，MMDetection 3.0 对模型的各个组件接口也进行了重构和简化，以支撑更加丰富的检测算法和下游应用。MMDetection 3.0 的运行速度和基准精度也得到了进一步优化，达到了现有框架的最优水平。另外，我们还研发了高精度模型 RTMDet，并和热情的社区开发者一起合作，开发了 M
mmdetection框架的安装、训练与测试
John's Blogs
12-19 1038
1、框架介绍 mmdetection is an open source object detection toolbox based on PyTorch. It is a part of the open-mmlab project developed by Multimedia Laboratory, CUHK. Major features 1、Modular Design We dec...
mmdet之训练和推理
deep_love1314的博客
06-20 4247
mmdetection的训练和推理
pytorch及mmdet模型训练学习笔记
ydestspring的博客
09-11 1170
（1）定义模型基本操作： 定义一个class继承BaseModule，class为模型的类 一个class中包括2部分，init和forward函数 init为初始化，固定套路继承父类init，用super函数写 super(BasicBlock, self).__init__(init_cfg) forward为前向传播函数，即定义数据进来后如何前向传播，包含了数据输入，处理，输出过程。 （2）具体分析一个forward函数 def _inner_forward(x): id
mmdet阅读笔记
寂寞的小乞丐
07-08 805
不清楚可以点击查看 mmdet 后续陆续增加源码注释 -- mmdetection.configs注意： _base_里面的文件都是基础的配置，后面的配置文件调用之后可以修改，以后面的为准 configs/base/dataset: 基础数据的配置文件 configs/base/models: 基础模型的配置文件 configs/base/schedules: 基础超参数的配置文件 co...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值