mmdetection自定义backbone(转)

一时失言乱红尘 2023-07-09 10:25 4阅读 0赞

前面我们零散的了解了mmdetection用到的一些python和PyTorch的知识。

现在我们开始深入算法模型来学习，这个模块我们尝试自定义一个se\_resnet50来学习自定义backbone.

在mmdetection/mmdet/models/backbone文件下创建一个senet.py的python文件。

"""  
ResNet code gently borrowed from  
https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py  
"""  
from \_\_future\_\_ import print\_function, division, absolute\_import  
from collections import OrderedDict  
from ..registry import BACKBONES  
from mmcv.runner import load\_checkpoint  
import logging  
from mmcv.cnn import constant\_init, kaiming\_init  
import math  
  
import torch.nn as nn  
from torch.utils import model\_zoo  
  
\_\_all\_\_ = \['SENet', 'senet154', 'se\_resnet50', 'se\_resnet101', 'se\_resnet152',  
'se\_resnext50\_32x4d', 'se\_resnext101\_32x4d'\]  
  
pretrained\_settings = \{  
'senet154': \{  
'imagenet': \{  
'url': 'http://data.lip6.fr/cadene/pretrainedmodels/senet154-c7b49a05.pth',  
'input\_space': 'RGB',  
'input\_size': \[3, 224, 224\],  
'input\_range': \[0, 1\],  
'mean': \[0.485, 0.456, 0.406\],  
'std': \[0.229, 0.224, 0.225\],  
'num\_classes': 1000  
\}  
\},  
'se\_resnet50': \{  
'imagenet': \{  
'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se\_resnet50-ce0d4300.pth',  
'input\_space': 'RGB',  
'input\_size': \[3, 224, 224\],  
'input\_range': \[0, 1\],  
'mean': \[0.485, 0.456, 0.406\],  
'std': \[0.229, 0.224, 0.225\],  
'num\_classes': 1000  
\}  
\},  
'se\_resnet101': \{  
'imagenet': \{  
'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se\_resnet101-7e38fcc6.pth',  
'input\_space': 'RGB',  
'input\_size': \[3, 224, 224\],  
'input\_range': \[0, 1\],  
'mean': \[0.485, 0.456, 0.406\],  
'std': \[0.229, 0.224, 0.225\],  
'num\_classes': 1000  
\}  
\},  
'se\_resnet152': \{  
'imagenet': \{  
'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se\_resnet152-d17c99b7.pth',  
'input\_space': 'RGB',  
'input\_size': \[3, 224, 224\],  
'input\_range': \[0, 1\],  
'mean': \[0.485, 0.456, 0.406\],  
'std': \[0.229, 0.224, 0.225\],  
'num\_classes': 1000  
\}  
\},  
'se\_resnext50\_32x4d': \{  
'imagenet': \{  
'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se\_resnext50\_32x4d-a260b3a4.pth',  
'input\_space': 'RGB',  
'input\_size': \[3, 224, 224\],  
'input\_range': \[0, 1\],  
'mean': \[0.485, 0.456, 0.406\],  
'std': \[0.229, 0.224, 0.225\],  
'num\_classes': 1000  
\}  
\},  
'se\_resnext101\_32x4d': \{  
'imagenet': \{  
'url': 'http://data.lip6.fr/cadene/pretrainedmodels/se\_resnext101\_32x4d-3b2fe3d8.pth',  
'input\_space': 'RGB',  
'input\_size': \[3, 224, 224\],  
'input\_range': \[0, 1\],  
'mean': \[0.485, 0.456, 0.406\],  
'std': \[0.229, 0.224, 0.225\],  
'num\_classes': 1000  
\}  
\},  
\}  
  
  
class SEModule(nn.Module):  
  
def \_\_init\_\_(self, channels, reduction):  
super(SEModule, self).\_\_init\_\_()  
self.avg\_pool = nn.AdaptiveAvgPool2d(1)  
self.fc1 = nn.Conv2d(channels, channels // reduction, kernel\_size=1,  
padding=0)  
self.relu = nn.ReLU(inplace=True)  
self.fc2 = nn.Conv2d(channels // reduction, channels, kernel\_size=1,  
padding=0)  
self.sigmoid = nn.Sigmoid()  
  
def forward(self, x):  
module\_input = x  
x = self.avg\_pool(x)  
x = self.fc1(x)  
x = self.relu(x)  
x = self.fc2(x)  
x = self.sigmoid(x)  
return module\_input \* x  
  
  
  
class Bottleneck(nn.Module):  
"""  
Base class for bottlenecks that implements \`forward()\` method.  
"""  
  
def forward(self, x):  
residual = x  
  
out = self.conv1(x)  
out = self.bn1(out)  
out = self.relu(out)  
  
out = self.conv2(out)  
out = self.bn2(out)  
out = self.relu(out)  
  
out = self.conv3(out)  
out = self.bn3(out)  
  
if self.downsample is not None:  
residual = self.downsample(x)  
  
out = self.se\_module(out) + residual  
out = self.relu(out)  
  
return out  
  
  
class SEBottleneck(Bottleneck):  
"""  
Bottleneck for SENet154.  
"""  
expansion = 4  
  
def \_\_init\_\_(self, inplanes, planes, groups, reduction, stride=1,  
downsample=None):  
super(SEBottleneck, self).\_\_init\_\_()  
self.conv1 = nn.Conv2d(inplanes, planes \* 2, kernel\_size=1, bias=False)  
self.bn1 = nn.BatchNorm2d(planes \* 2)  
self.conv2 = nn.Conv2d(planes \* 2, planes \* 4, kernel\_size=3,  
stride=stride, padding=1, groups=groups,  
bias=False)  
self.bn2 = nn.BatchNorm2d(planes \* 4)  
self.conv3 = nn.Conv2d(planes \* 4, planes \* 4, kernel\_size=1,  
bias=False)  
self.bn3 = nn.BatchNorm2d(planes \* 4)  
self.relu = nn.ReLU(inplace=True)  
self.se\_module = SEModule(planes \* 4, reduction=reduction)  
self.downsample = downsample  
self.stride = stride  
  
  
class SEResNetBottleneck(Bottleneck):  
"""  
ResNet bottleneck with a Squeeze-and-Excitation module. It follows Caffe  
implementation and uses \`stride=stride\` in \`conv1\` and not in \`conv2\`  
(the latter is used in the torchvision implementation of ResNet).  
"""  
expansion = 4  
  
def \_\_init\_\_(self, inplanes, planes, groups, reduction, stride=1,  
downsample=None):  
super(SEResNetBottleneck, self).\_\_init\_\_()  
self.conv1 = nn.Conv2d(inplanes, planes, kernel\_size=1, bias=False,  
stride=stride)  
self.bn1 = nn.BatchNorm2d(planes)  
self.conv2 = nn.Conv2d(planes, planes, kernel\_size=3, padding=1,  
groups=groups, bias=False)  
self.bn2 = nn.BatchNorm2d(planes)  
self.conv3 = nn.Conv2d(planes, planes \* 4, kernel\_size=1, bias=False)  
self.bn3 = nn.BatchNorm2d(planes \* 4)  
self.relu = nn.ReLU(inplace=True)  
self.se\_module = SEModule(planes \* 4, reduction=reduction)  
self.downsample = downsample  
self.stride = stride  
  
  
class SEResNeXtBottleneck(Bottleneck):  
"""  
ResNeXt bottleneck type C with a Squeeze-and-Excitation module.  
"""  
expansion = 4  
  
def \_\_init\_\_(self, inplanes, planes, groups, reduction, stride=1,  
downsample=None, base\_width=4):  
super(SEResNeXtBottleneck, self).\_\_init\_\_()  
width = math.floor(planes \* (base\_width / 64)) \* groups  
self.conv1 = nn.Conv2d(inplanes, width, kernel\_size=1, bias=False,  
stride=1)  
self.bn1 = nn.BatchNorm2d(width)  
self.conv2 = nn.Conv2d(width, width, kernel\_size=3, stride=stride,  
padding=1, groups=groups, bias=False)  
self.bn2 = nn.BatchNorm2d(width)  
self.conv3 = nn.Conv2d(width, planes \* 4, kernel\_size=1, bias=False)  
self.bn3 = nn.BatchNorm2d(planes \* 4)  
self.relu = nn.ReLU(inplace=True)  
self.se\_module = SEModule(planes \* 4, reduction=reduction)  
self.downsample = downsample  
self.stride = stride  
  
  
bottleneck\_dic = \{  
'SEBottleneck': SEBottleneck,  
'SEResNetBottleneck': SEResNetBottleneck,  
'SEResNeXtBottleneck': SEResNeXtBottleneck  
\}  
  
@BACKBONES.register\_module  
class SENet(nn.Module):  
  
def \_\_init\_\_(self, block, layers, groups, reduction, dropout\_p=0.2,  
inplanes=128, input\_3x3=True, downsample\_kernel\_size=3,  
downsample\_padding=1,norm\_eval=True, frozen\_stages=-1, zero\_init\_residual=True, num\_classes=1000):  
"""  
Parameters  
\----------  
block (nn.Module): Bottleneck class.  
\- For SENet154: SEBottleneck  
\- For SE-ResNet models: SEResNetBottleneck  
\- For SE-ResNeXt models: SEResNeXtBottleneck  
layers (list of ints): Number of residual blocks for 4 layers of the  
network (layer1...layer4).  
groups (int): Number of groups for the 3x3 convolution in each  
bottleneck block.  
\- For SENet154: 64  
\- For SE-ResNet models: 1  
\- For SE-ResNeXt models: 32  
reduction (int): Reduction ratio for Squeeze-and-Excitation modules.  
\- For all models: 16  
dropout\_p (float or None): Drop probability for the Dropout layer.  
If \`None\` the Dropout layer is not used.  
\- For SENet154: 0.2  
\- For SE-ResNet models: None  
\- For SE-ResNeXt models: None  
inplanes (int): Number of input channels for layer1.  
\- For SENet154: 128  
\- For SE-ResNet models: 64  
\- For SE-ResNeXt models: 64  
input\_3x3 (bool): If \`True\`, use three 3x3 convolutions instead of  
a single 7x7 convolution in layer0.  
\- For SENet154: True  
\- For SE-ResNet models: False  
\- For SE-ResNeXt models: False  
downsample\_kernel\_size (int): Kernel size for downsampling convolutions  
in layer2, layer3 and layer4.  
\- For SENet154: 3  
\- For SE-ResNet models: 1  
\- For SE-ResNeXt models: 1  
downsample\_padding (int): Padding for downsampling convolutions in  
layer2, layer3 and layer4.  
\- For SENet154: 1  
\- For SE-ResNet models: 0  
\- For SE-ResNeXt models: 0  
num\_classes (int): Number of outputs in \`last\_linear\` layer.  
\- For all models: 1000  
"""  
super(SENet, self).\_\_init\_\_()  
block = bottleneck\_dic\[block\]  
self.inplanes = inplanes  
self.frozen\_stages = frozen\_stages  
self.norm\_eval = norm\_eval  
self.zero\_init\_residual = zero\_init\_residual  
if input\_3x3:  
layer0\_modules = \[  
('conv1', nn.Conv2d(3, 64, 3, stride=2, padding=1,  
bias=False)),  
('bn1', nn.BatchNorm2d(64)),  
('relu1', nn.ReLU(inplace=True)),  
('conv2', nn.Conv2d(64, 64, 3, stride=1, padding=1,  
bias=False)),  
('bn2', nn.BatchNorm2d(64)),  
('relu2', nn.ReLU(inplace=True)),  
('conv3', nn.Conv2d(64, inplanes, 3, stride=1, padding=1,  
bias=False)),  
('bn3', nn.BatchNorm2d(inplanes)),  
('relu3', nn.ReLU(inplace=True)),  
\]  
else:  
layer0\_modules = \[  
('conv1', nn.Conv2d(3, inplanes, kernel\_size=7, stride=2,  
padding=3, bias=False)),  
('bn1', nn.BatchNorm2d(inplanes)),  
('relu1', nn.ReLU(inplace=True)),  
\]  
\# To preserve compatibility with Caffe weights \`ceil\_mode=True\`  
\# is used instead of \`padding=1\`.  
layer0\_modules.append(('pool', nn.MaxPool2d(3, stride=2,  
ceil\_mode=True)))  
self.layer0 = nn.Sequential(OrderedDict(layer0\_modules))  
self.layer1 = self.\_make\_layer(  
block,  
planes=64,  
blocks=layers\[0\],  
groups=groups,  
reduction=reduction,  
downsample\_kernel\_size=1,  
downsample\_padding=0  
)  
self.layer2 = self.\_make\_layer(  
block,  
planes=128,  
blocks=layers\[1\],  
stride=2,  
groups=groups,  
reduction=reduction,  
downsample\_kernel\_size=downsample\_kernel\_size,  
downsample\_padding=downsample\_padding  
)  
self.layer3 = self.\_make\_layer(  
block,  
planes=256,  
blocks=layers\[2\],  
stride=2,  
groups=groups,  
reduction=reduction,  
downsample\_kernel\_size=downsample\_kernel\_size,  
downsample\_padding=downsample\_padding  
)  
self.layer4 = self.\_make\_layer(  
block,  
planes=512,  
blocks=layers\[3\],  
stride=2,  
groups=groups,  
reduction=reduction,  
downsample\_kernel\_size=downsample\_kernel\_size,  
downsample\_padding=downsample\_padding  
)  
\# self.avg\_pool = nn.AvgPool2d(7, stride=1)  
\# self.dropout = nn.Dropout(dropout\_p) if dropout\_p is not None else None  
\# self.last\_linear = nn.Linear(512 \* block.expansion, num\_classes)  
self.\_freeze\_stages()  
  
def \_freeze\_stages(self):  
if self.frozen\_stages >= 0:  
for m in \[self.layer0\]:  
m.eval()  
for param in m.parameters():  
param.requires\_grad = False  
for i in range(1, self.frozen\_stages + 1):  
m = getattr(self, 'layer\{\}'.format(i))  
m.eval()  
for param in m.parameters():  
param.requires\_grad = False  
  
def init\_weights(self, pretrained=None):  
if isinstance(pretrained, str):  
logger = logging.getLogger()  
load\_checkpoint(self, pretrained, strict=False, logger=logger)  
elif pretrained is None:  
for m in self.modules():  
if isinstance(m, nn.Conv2d):  
kaiming\_init(m)  
elif isinstance(m, nn.BatchNorm2d):  
constant\_init(m, 1)  
if self.zero\_init\_residual:  
for m in self.modules():  
if isinstance(m, Bottleneck):  
constant\_init(m.bn3, 0)  
else:  
raise TypeError('pretrained must be a str or None')  
  
def \_make\_layer(self, block, planes, blocks, groups, reduction, stride=1,  
downsample\_kernel\_size=1, downsample\_padding=0):  
downsample = None  
if stride != 1 or self.inplanes != planes \* block.expansion:  
downsample = nn.Sequential(  
nn.Conv2d(self.inplanes, planes \* block.expansion,  
kernel\_size=downsample\_kernel\_size, stride=stride,  
padding=downsample\_padding, bias=False),  
nn.BatchNorm2d(planes \* block.expansion),  
)  
  
layers = \[\]  
layers.append(block(self.inplanes, planes, groups, reduction, stride,  
downsample))  
self.inplanes = planes \* block.expansion  
for i in range(1, blocks):  
layers.append(block(self.inplanes, planes, groups, reduction))  
  
return nn.Sequential(\*layers)  
  
def features(self, x):  
outputs = \[\]  
x = self.layer0(x)  
x = self.layer1(x)  
outputs.append(x)  
x = self.layer2(x)  
outputs.append(x)  
x = self.layer3(x)  
outputs.append(x)  
x = self.layer4(x)  
outputs.append(x)  
return x, outputs  
'''  
def logits(self, x):  
x = self.avg\_pool(x)  
if self.dropout is not None:  
x = self.dropout(x)  
x = x.view(x.size(0), -1)  
x = self.last\_linear(x)  
return x  
'''  
def forward(self, x):  
x, outputs = self.features(x)  
\# x = self.logits(x)  
return outputs \# x  
  
def train(self, mode=True):  
super(SENet, self).train(mode)  
self.\_freeze\_stages()  
if mode and self.norm\_eval:  
for m in self.modules():  
\# trick: eval have effect on BatchNorm only  
if isinstance(m, (nn.BatchNorm2d)):  
m.eval()  
  
def initialize\_pretrained\_model(model, num\_classes, settings):  
assert num\_classes == settings\['num\_classes'\], \\  
'num\_classes should be \{\}, but is \{\}'.format(  
settings\['num\_classes'\], num\_classes)  
model.load\_state\_dict(model\_zoo.load\_url(settings\['url'\]))  
model.input\_space = settings\['input\_space'\]  
model.input\_size = settings\['input\_size'\]  
model.input\_range = settings\['input\_range'\]  
model.mean = settings\['mean'\]  
model.std = settings\['std'\]  
  
  
def senet154(num\_classes=1000, pretrained='imagenet'):  
model = SENet(SEBottleneck, \[3, 8, 36, 3\], groups=64, reduction=16,  
dropout\_p=0.2, num\_classes=num\_classes)  
if pretrained is not None:  
settings = pretrained\_settings\['senet154'\]\[pretrained\]  
initialize\_pretrained\_model(model, num\_classes, settings)  
return model  
  
  
def se\_resnet50(num\_classes=1000, pretrained='imagenet'):  
model = SENet(SEResNetBottleneck, \[3, 4, 6, 3\], groups=1, reduction=16,  
dropout\_p=None, inplanes=64, input\_3x3=False,  
downsample\_kernel\_size=1, downsample\_padding=0,  
num\_classes=num\_classes)  
if pretrained is not None:  
settings = pretrained\_settings\['se\_resnet50'\]\[pretrained\]  
initialize\_pretrained\_model(model, num\_classes, settings)  
return model  
  
  
def se\_resnet101(num\_classes=1000, pretrained='imagenet'):  
model = SENet(SEResNetBottleneck, \[3, 4, 23, 3\], groups=1, reduction=16,  
dropout\_p=None, inplanes=64, input\_3x3=False,  
downsample\_kernel\_size=1, downsample\_padding=0,  
num\_classes=num\_classes)  
if pretrained is not None:  
settings = pretrained\_settings\['se\_resnet101'\]\[pretrained\]  
initialize\_pretrained\_model(model, num\_classes, settings)  
return model  
  
  
def se\_resnet152(num\_classes=1000, pretrained='imagenet'):  
model = SENet(SEResNetBottleneck, \[3, 8, 36, 3\], groups=1, reduction=16,  
dropout\_p=None, inplanes=64, input\_3x3=False,  
downsample\_kernel\_size=1, downsample\_padding=0,  
num\_classes=num\_classes)  
if pretrained is not None:  
settings = pretrained\_settings\['se\_resnet152'\]\[pretrained\]  
initialize\_pretrained\_model(model, num\_classes, settings)  
return model  
  
  
def se\_resnext50\_32x4d(num\_classes=1000, pretrained='imagenet'):  
model = SENet(SEResNeXtBottleneck, \[3, 4, 6, 3\], groups=32, reduction=16,  
dropout\_p=None, inplanes=64, input\_3x3=False,  
downsample\_kernel\_size=1, downsample\_padding=0,  
num\_classes=num\_classes)  
if pretrained is not None:  
settings = pretrained\_settings\['se\_resnext50\_32x4d'\]\[pretrained\]  
initialize\_pretrained\_model(model, num\_classes, settings)  
return model  
  
  
def se\_resnext101\_32x4d(num\_classes=1000, pretrained='imagenet'):  
model = SENet(SEResNeXtBottleneck, \[3, 4, 23, 3\], groups=32, reduction=16,  
dropout\_p=None, inplanes=64, input\_3x3=False,  
downsample\_kernel\_size=1, downsample\_padding=0,  
num\_classes=num\_classes)  
if pretrained is not None:  
settings = pretrained\_settings\['se\_resnext101\_32x4d'\]\[pretrained\]  
initialize\_pretrained\_model(model, num\_classes, settings)  
return model  
上面就是senet.py的内容了。

主要是下面这里，自定义好类后，需要进行注册。

@BACKBONES.register\_module  
class SENet(nn.Module):  
还有\_\_init\_\_.py文件里也需要添加相应的模块

from .hrnet import HRNet  
from .resnet import ResNet, make\_res\_layer  
from .resnext import ResNeXt  
from .ssd\_vgg import SSDVGG  
from .senet import SENet  
  
\_\_all\_\_ = \['SENet','ResNet', 'make\_res\_layer', 'ResNeXt', 'SSDVGG', 'HRNet'\]  
最后在mmdetection/configs/pascal\_voc目录下创建配置文件faster\_rcnn\_ser50\_fpn\_1x\_voc0712.py。

\# model settings  
model = dict(  
type='FasterRCNN',  
\#pretrained='torchvision://resnet50',  
pretrained='/home/yyf/mmdetection/checkpoints/se\_resnet50-ce0d4300.pth',  
backbone=dict(  
type='SENet',  
block='SEResNetBottleneck',  
layers=\[3, 4, 6, 3\],  
groups=1,  
reduction=16,  
dropout\_p=None,  
inplanes=64,  
input\_3x3=False,  
downsample\_kernel\_size=1,  
downsample\_padding=0,  
frozen\_stages=1  
\#depth=50,  
\#num\_stages=4,  
\#out\_indices=(0, 1, 2, 3),  
\#style='pytorch'  
),  
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\_scales=\[8\],  
anchor\_ratios=\[0.5, 1.0, 2.0\],  
anchor\_strides=\[4, 8, 16, 32, 64\],  
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='SmoothL1Loss', beta=1.0 / 9.0, loss\_weight=1.0)),  
bbox\_roi\_extractor=dict(  
type='SingleRoIExtractor',  
roi\_layer=dict(type='RoIAlign', out\_size=7, sample\_num=2),  
out\_channels=256,  
featmap\_strides=\[4, 8, 16, 32\]),  
bbox\_head=dict(  
type='SharedFCBBoxHead',  
num\_fcs=2,  
in\_channels=256,  
fc\_out\_channels=1024,  
roi\_feat\_size=7,  
num\_classes=21,  
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='SmoothL1Loss', beta=1.0, 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,  
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=0,  
pos\_weight=-1,  
debug=False),  
rpn\_proposal=dict(  
nms\_across\_levels=False,  
nms\_pre=2000,  
nms\_post=2000,  
max\_num=2000,  
nms\_thr=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,  
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\_across\_levels=False,  
nms\_pre=1000,  
nms\_post=1000,  
max\_num=1000,  
nms\_thr=0.7,  
min\_bbox\_size=0),  
rcnn=dict(  
score\_thr=0.05, nms=dict(type='nms', iou\_thr=0.5), max\_per\_img=100)  
\# soft-nms is also supported for rcnn testing  
\# e.g., nms=dict(type='soft\_nms', iou\_thr=0.5, min\_score=0.05)  
)  
\# dataset settings  
dataset\_type = 'VOCDataset'  
data\_root = 'data/VOCdevkit/'  
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(  
imgs\_per\_gpu=2,  
workers\_per\_gpu=2,  
train=dict(  
type='RepeatDataset',  
times=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/'\],  
pipeline=train\_pipeline)),  
val=dict(  
type=dataset\_type,  
ann\_file=data\_root + 'VOC2007/ImageSets/Main/test.txt',  
img\_prefix=data\_root + 'VOC2007/',  
pipeline=test\_pipeline),  
test=dict(  
type=dataset\_type,  
ann\_file=data\_root + 'VOC2007/ImageSets/Main/test.txt',  
img\_prefix=data\_root + 'VOC2007/',  
pipeline=test\_pipeline))  
\# optimizer  
optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight\_decay=0.0001)  
optimizer\_config = dict(grad\_clip=dict(max\_norm=35, norm\_type=2))  
\# learning policy  
lr\_config = dict(policy='step', step=\[3\]) \# actual epoch = 3 \* 3 = 9  
checkpoint\_config = dict(interval=1)  
\# yapf:disable  
log\_config = dict(  
interval=50,  
hooks=\[  
dict(type='TextLoggerHook'),  
\# dict(type='TensorboardLoggerHook')  
\])  
\# yapf:enable  
\# runtime settings  
total\_epochs = 4 \# actual epoch = 4 \* 3 = 12  
dist\_params = dict(backend='nccl')  
log\_level = 'INFO'  
work\_dir = './work\_dirs/faster\_rcnn\_ser50\_fpn\_1x\_voc0712'  
load\_from = None  
resume\_from = None  
workflow = \[('train', 1)\]  
上面都做好后，还要重新运行python setup.py develop重新编译安装。

完成后就可以愉快的玩耍了。

参考内容：参考  
————————————————  
版权声明：本文为CSDN博主「Haku\_yyf」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/haku\_yyf/article/details/102504235