CV+DeepLearning——网络架构Pytorch复现系列——Detection(二：RtinaNet)更换backbones(DarkNet)

上一话

CV&＃43;Deep Learning——网络架构Pytorch复现系列——Detection(一&＃xff1a;SSD:Single Shot MultiBox Detector 4.推理Detect)https://blog.csdn.net/XiaoyYidiaodiao/article/details/128683973?spm&＃61;1001.2014.3001.5501

复现Object Detection&＃xff0c;会复现的网络架构有&＃xff1a;

1.SSD: Single Shot MultiBox Detector(√)

2.RetinaNet(√)

3.Faster RCNN

4.YOLO系列

....

代码&＃xff1a;

https://github.com/HanXiaoyiGitHub/Simple-CV-Pytorch-masterhttps://github.com/HanXiaoyiGitHub/Simple-CV-Pytorch-master

2.复现RetinaNet

之前已经讲过RetinaNet&＃xff0c;链接如下&＃xff1a;

目标检测——RetinaNet-Focal Loss 焦点损失函数的理解https://blog.csdn.net/XiaoyYidiaodiao/article/details/124553661?spm&＃61;1001.2014.3001.5502

也不想做过多的讲解了&＃xff0c;就讲讲在RetinaNet中是如何更换Backbones(将以前的ResNet更换为DarkNet)

之前ResNet骨干网络的代码

我懒得写了直接调用Pytorch包的&＃xff0c;但是值得注意的是输出的feature map的channels可能需要修改&＃xff08;这里我在RetinaNet.py中进行了修改&＃xff09;&＃xff0c;与之后Neck&＃xff08;FPN&＃xff09;网络中输入channles匹配。

import torch
from torch import nn
from torchvision.models import resnet18, resnet34, resnet50, \
resnet101, resnet152
class ResNet(nn.Module):
def __init__(self, resnet_type&＃61;"resnet50", pretrained&＃61;False):
super(ResNet, self).__init__()
if resnet_type &＃61;&＃61; "resnet18":
self.model &＃61; resnet18(pretrained&＃61;pretrained)
elif resnet_type &＃61;&＃61; "resnet34":
self.model &＃61; resnet34(pretrained&＃61;pretrained)
elif resnet_type &＃61;&＃61; "resnet50":
self.model &＃61; resnet50(pretrained&＃61;pretrained)
elif resnet_type &＃61;&＃61; "resnet101":
self.model &＃61; resnet101(pretrained&＃61;pretrained)
elif resnet_type &＃61;&＃61; "resnet152":
self.model &＃61; resnet152(pretrained&＃61;pretrained)
del self.model.fc
del self.model.avgpool
def forward(self, x):
x &＃61; self.model.conv1(x)
x &＃61; self.model.bn1(x)
x &＃61; self.model.relu(x)
x &＃61; self.model.maxpool(x)
x &＃61; self.model.layer1(x)
C3 &＃61; self.model.layer2(x)
C4 &＃61; self.model.layer3(C3)
C5 &＃61; self.model.layer4(C4)
del x
return [C3, C4, C5]
if __name__ &＃61;&＃61; "__main__":
backbone &＃61; ResNet(resnet_type&＃61;&＃39;resnet18&＃39;, pretrained&＃61;True)
x &＃61; torch.randn([16, 3, 512, 512])
C3, C4, C5 &＃61; backbone(x)
print(C3.shape) # torch.Size([16, 512, 64, 64])
print(C4.shape) # torch.Size([16, 1024, 32, 32])
print(C5.shape) # torch.Size([16, 2048, 16, 16])

DarkNet骨干网络的代码

这里更换的backbones是DarkNetTiny&＃xff0c;DarkNet19和DarkNet53&＃xff0c;DarkNet系列是出自YOLO系列&＃xff0c;其中DarkNet19是来自于YOLO9000(也就是我们通常意义上的YOLOv2[1]&＃xff0c;DarkNet53是来自于最经典的YOLOv3[2]&＃xff0c;而DarkNetTiny是来自YOLOv3-Tiny[2]。

import torch
import torch.nn as nn
__all__ &＃61; [
&＃39;darknettiny&＃39;,
&＃39;darknet19&＃39;,
&＃39;darknet53&＃39;,
]
class DarkNet(nn.Module):
def __init__(self, darknet_type&＃61;&＃39;darknet19&＃39;):
super(DarkNet, self).__init__()
self.darknet_type &＃61; darknet_type
if darknet_type &＃61;&＃61; &＃39;darknettiny&＃39;:
self.model &＃61; darknettiny()
elif darknet_type &＃61;&＃61; &＃39;darknet19&＃39;:
self.model &＃61; darknet19()
elif darknet_type &＃61;&＃61; &＃39;darknet53&＃39;:
self.model &＃61; darknet53()
def forward(self, x):
out &＃61; self.model(x)
return out
class ActBlock(nn.Module):
def __init__(self, act_type&＃61;&＃39;leakyrelu&＃39;, inplace&＃61;True):
super(ActBlock, self).__init__()
assert act_type in [&＃39;silu&＃39;, &＃39;relu&＃39;, &＃39;leakyrelu&＃39;], \
"Unsupported activation function!"
if act_type &＃61;&＃61; &＃39;silu&＃39;:
self.act &＃61; nn.SiLU(inplace&＃61;inplace)
elif act_type &＃61;&＃61; &＃39;relu&＃39;:
self.act &＃61; nn.ReLU(inplace&＃61;inplace)
elif act_type &＃61;&＃61; &＃39;leakyrelu&＃39;:
self.act &＃61; nn.LeakyReLU(0.1, inplace&＃61;inplace)
def forward(self, x):
x &＃61; self.act(x)
return x
class ConvBlock(nn.Module):
def __init__(self, inplanes, planes, kernel_size, stride, padding, groups&＃61;1, has_bn&＃61;True, has_act&＃61;True,
act_type&＃61;&＃39;leakyrelu&＃39;):
super(ConvBlock, self).__init__()
bias &＃61; False if has_bn else True
self.layer &＃61; nn.Sequential(
nn.Conv2d(in_channels&＃61;inplanes, out_channels&＃61;planes, kernel_size&＃61;kernel_size, stride&＃61;stride,
padding&＃61;padding, groups&＃61;groups, bias&＃61;bias),
nn.BatchNorm2d(planes) if has_bn else nn.Sequential(),
ActBlock(act_type&＃61;act_type, inplace&＃61;True) if has_act else nn.Sequential()
)
def forward(self, x):
x &＃61; self.layer(x)
return x
class DarkNetTiny(nn.Module):
def __init__(self, act_type&＃61;&＃39;leakyrelu&＃39;):
super(DarkNetTiny, self).__init__()
self.conv1 &＃61; ConvBlock(inplanes&＃61;3, planes&＃61;16, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1, groups&＃61;1, has_bn&＃61;True,
has_act&＃61;True, act_type&＃61;act_type)
self.conv2 &＃61; ConvBlock(inplanes&＃61;16, planes&＃61;32, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1, groups&＃61;1, has_bn&＃61;True,
has_act&＃61;True, act_type&＃61;act_type)
self.conv3 &＃61; ConvBlock(inplanes&＃61;32, planes&＃61;64, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1, groups&＃61;1, has_bn&＃61;True,
has_act&＃61;True, act_type&＃61;act_type)
self.conv4 &＃61; ConvBlock(inplanes&＃61;64, planes&＃61;128, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1, groups&＃61;1, has_bn&＃61;True,
has_act&＃61;True, act_type&＃61;act_type)
self.conv5 &＃61; ConvBlock(inplanes&＃61;128, planes&＃61;256, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1, groups&＃61;1, has_bn&＃61;True,
has_act&＃61;True, act_type&＃61;act_type)
self.conv6 &＃61; ConvBlock(inplanes&＃61;256, planes&＃61;512, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1, groups&＃61;1, has_bn&＃61;True,
has_act&＃61;True, act_type&＃61;act_type)
self.maxpool &＃61; nn.MaxPool2d(kernel_size&＃61;2, stride&＃61;2)
self.zeropad &＃61; nn.ZeroPad2d((0, 1, 0, 1))
self.last_maxpool &＃61; nn.MaxPool2d(kernel_size&＃61;2, stride&＃61;1)
self.out_channels &＃61; [64, 128, 256]
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode&＃61;&＃39;fan_out&＃39;, nonlinearity&＃61;&＃39;relu&＃39;)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def forward(self, x):
x &＃61; self.conv1(x)
x &＃61; self.maxpool(x)
x &＃61; self.conv2(x)
x &＃61; self.maxpool(x)
C3 &＃61; self.conv3(x)
C3 &＃61; self.maxpool(C3)
C4 &＃61; self.conv4(C3)
C4 &＃61; self.maxpool(C4) # 128
C5 &＃61; self.conv5(C4)
C5 &＃61; self.maxpool(C5) # 256
del x
return [C3, C4, C5]
class D19Block(nn.Module):
def __init__(self, inplanes, planes, layer_num, use_maxpool&＃61;False, act_type&＃61;&＃39;leakyrelu&＃39;):
super(D19Block, self).__init__()
self.use_maxpool &＃61; use_maxpool
layers &＃61; []
for i in range(0, layer_num):
if i % 2 &＃61;&＃61; 0:
layers.append(
ConvBlock(inplanes&＃61;inplanes, planes&＃61;planes, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1, groups&＃61;1,
has_bn&＃61;True, has_act&＃61;True, act_type&＃61;act_type))
else:
layers.append(
ConvBlock(inplanes&＃61;planes, planes&＃61;inplanes, kernel_size&＃61;1, stride&＃61;1, padding&＃61;0, groups&＃61;1,
has_bn&＃61;True, has_act&＃61;True, act_type&＃61;act_type))
self.D19Block &＃61; nn.Sequential(*layers)
if self.use_maxpool:
self.maxpool &＃61; nn.MaxPool2d(kernel_size&＃61;2, stride&＃61;2)
def forward(self, x):
x &＃61; self.D19Block(x)
if self.use_maxpool:
x &＃61; self.maxpool(x)
return x
class DarkNet19(nn.Module):
def __init__(self, act_type&＃61;&＃39;leakyrelu&＃39;):
super(DarkNet19, self).__init__()
self.layer1 &＃61; ConvBlock(inplanes&＃61;3, planes&＃61;32, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1, groups&＃61;1, has_bn&＃61;True,
has_act&＃61;True, act_type&＃61;act_type)
self.layer2 &＃61; D19Block(inplanes&＃61;32, planes&＃61;64, layer_num&＃61;1, use_maxpool&＃61;True, act_type&＃61;act_type)
self.layer3 &＃61; D19Block(inplanes&＃61;64, planes&＃61;128, layer_num&＃61;3, use_maxpool&＃61;True, act_type&＃61;act_type)
self.layer4 &＃61; D19Block(inplanes&＃61;128, planes&＃61;256, layer_num&＃61;3, use_maxpool&＃61;True, act_type&＃61;act_type)
self.layer5 &＃61; D19Block(inplanes&＃61;256, planes&＃61;512, layer_num&＃61;5, use_maxpool&＃61;True, act_type&＃61;act_type)
self.layer6 &＃61; D19Block(inplanes&＃61;512, planes&＃61;1024, layer_num&＃61;5, use_maxpool&＃61;False, act_type&＃61;act_type)
self.maxpool &＃61; nn.MaxPool2d(kernel_size&＃61;2, stride&＃61;2)
self.out_channels &＃61; [128, 256, 512]
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode&＃61;&＃39;fan_out&＃39;, nonlinearity&＃61;&＃39;relu&＃39;)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def forward(self, x):
x &＃61; self.layer1(x)
x &＃61; self.maxpool(x)
x &＃61; self.layer2(x)
C3 &＃61; self.layer3(x)
C4 &＃61; self.layer4(C3)
C5 &＃61; self.layer5(C4)
del x
return [C3, C4, C5]
# conv*2&＃43;residual
class BasicBlock(nn.Module):
def __init__(self, inplanes, planes):
super(BasicBlock, self).__init__()
self.conv1 &＃61; ConvBlock(inplanes&＃61;inplanes, planes&＃61;planes, kernel_size&＃61;1, stride&＃61;1, padding&＃61;0)
self.conv2 &＃61; ConvBlock(inplanes&＃61;planes, planes&＃61;planes * 2, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1)
def forward(self, x):
out &＃61; self.conv1(x)
out &＃61; self.conv2(out)
out &＃43;&＃61; x
del x
return out
class DarkNet53(nn.Module):
def __init__(self):
super(DarkNet53, self).__init__()
self.conv1 &＃61; ConvBlock(inplanes&＃61;3, planes&＃61;32, kernel_size&＃61;3, stride&＃61;1, padding&＃61;1)
self.conv2 &＃61; ConvBlock(inplanes&＃61;32, planes&＃61;64, kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
self.block1 &＃61; nn.Sequential(
BasicBlock(inplanes&＃61;64, planes&＃61;32),
ConvBlock(inplanes&＃61;64, planes&＃61;128, kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
) # 128
self.block2 &＃61; nn.Sequential(
BasicBlock(inplanes&＃61;128, planes&＃61;64),
BasicBlock(inplanes&＃61;128, planes&＃61;64),
ConvBlock(inplanes&＃61;128, planes&＃61;256, kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
) # 256
self.block3 &＃61; nn.Sequential(
BasicBlock(inplanes&＃61;256, planes&＃61;128),
BasicBlock(inplanes&＃61;256, planes&＃61;128),
BasicBlock(inplanes&＃61;256, planes&＃61;128),
BasicBlock(inplanes&＃61;256, planes&＃61;128),
BasicBlock(inplanes&＃61;256, planes&＃61;128),
BasicBlock(inplanes&＃61;256, planes&＃61;128),
BasicBlock(inplanes&＃61;256, planes&＃61;128),
BasicBlock(inplanes&＃61;256, planes&＃61;128),
ConvBlock(inplanes&＃61;256, planes&＃61;512, kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
) # 512
self.block4 &＃61; nn.Sequential(
BasicBlock(inplanes&＃61;512, planes&＃61;256),
BasicBlock(inplanes&＃61;512, planes&＃61;256),
BasicBlock(inplanes&＃61;512, planes&＃61;256),
BasicBlock(inplanes&＃61;512, planes&＃61;256),
BasicBlock(inplanes&＃61;512, planes&＃61;256),
BasicBlock(inplanes&＃61;512, planes&＃61;256),
BasicBlock(inplanes&＃61;512, planes&＃61;256),
BasicBlock(inplanes&＃61;512, planes&＃61;256),
ConvBlock(inplanes&＃61;512, planes&＃61;1024, kernel_size&＃61;3, stride&＃61;2, padding&＃61;1)
) # 1024
self.block5 &＃61; nn.Sequential(
BasicBlock(inplanes&＃61;1024, planes&＃61;512),
BasicBlock(inplanes&＃61;1024, planes&＃61;512),
BasicBlock(inplanes&＃61;1024, planes&＃61;512),
BasicBlock(inplanes&＃61;1024, planes&＃61;512)
)
self.out_channels &＃61; [256, 512, 1024]
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode&＃61;&＃39;fan_out&＃39;, nonlinearity&＃61;&＃39;relu&＃39;)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def forward(self, x):
x &＃61; self.conv1(x)
x &＃61; self.conv2(x)
x &＃61; self.block1(x)
C3 &＃61; self.block2(x)
C4 &＃61; self.block3(C3)
C5 &＃61; self.block4(C4)
del x
return [C3, C4, C5]
def darknettiny(**kwargs):
model &＃61; DarkNetTiny(**kwargs)
return model
def darknet19(**kwargs):
model &＃61; DarkNet19(**kwargs)
return model
def darknet53(**kwargs):
model &＃61; DarkNet53(**kwargs)
return model
if __name__ &＃61;&＃61; &＃39;__main__&＃39;:
x &＃61; torch.randn([8, 3, 512, 512])
darknet &＃61; DarkNet(darknet_type&＃61;&＃39;darknet53&＃39;)
[C3, C4, C5] &＃61; darknet(x)
print("C3.shape:{}".format(C3.shape))
print("C4.shape:{}".format(C4.shape))
print("C5.shape:{}".format(C5.shape))
# DarkNet53
# C3.shape: torch.Size([8, 256, 64, 64])
# C4.shape: torch.Size([8, 512, 32, 32])
# C5.shape: torch.Size([8, 1024, 16, 16])
# DarkNet19
# C3.shape: torch.Size([8, 128, 64, 64])
# C4.shape: torch.Size([8, 256, 32, 32])
# C5.shape: torch.Size([8, 512, 16, 16])
# DarkNetTiny
# C3.shape: torch.Size([8, 64, 64, 64])
# C4.shape: torch.Size([8, 128, 32, 32])
# C5.shape: torch.Size([8, 256, 16, 16])

如何在RetinaNet网络中使用呢&＃xff1f;我设置了个Backbones_type&＃xff0c;修改这个就行。

RetinaNet.py代码

import os
import sys
BASE_DIR &＃61; os.path.dirname(
os.path.dirname(
os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
import torch
import torch.nn as nn
from torchvision.ops import nms
from models.detection.RetinaNet.neck import FPN
from models.detection.RetinaNet.loss import FocalLoss
from models.detection.RetinaNet.anchor import Anchors
from models.detection.RetinaNet.head import clsHead, regHead
from models.detection.RetinaNet.backbones.ResNet import ResNet
from models.detection.RetinaNet.utils.ClipBoxes import ClipBoxes
from models.detection.RetinaNet.backbones.DarkNet import DarkNet
from models.detection.RetinaNet.utils.BBoxTransform import BBoxTransform
# assert input annotations are [x_min, y_min, x_max, y_max]
class RetinaNet(nn.Module):
def __init__(self,
backbones_type&＃61;"resnet50",
num_classes&＃61;80,
planes&＃61;256,
pretrained&＃61;False,
training&＃61;False):
super(RetinaNet, self).__init__()
self.backbones_type &＃61; backbones_type
# coco 80, voc 20
self.num_classes &＃61; num_classes
self.planes &＃61; planes
self.training &＃61; training
if backbones_type[:6] &＃61;&＃61; &＃39;resnet&＃39;:
self.backbone &＃61; ResNet(resnet_type&＃61;self.backbones_type,
pretrained&＃61;pretrained)
elif backbones_type[:7] &＃61;&＃61; &＃39;darknet&＃39;:
self.backbone &＃61; DarkNet(darknet_type&＃61;self.backbones_type)
expand_ratio &＃61; {
"resnet18": 1,
"resnet34": 1,
"resnet50": 4,
"resnet101": 4,
"resnet152": 4,
"darknettiny": 0.5,
"darknet19": 1,
"darknet53": 2
}
C3_inplanes, C4_inplanes, C5_inplanes &＃61; \
int(128 * expand_ratio[self.backbones_type]), \
int(256 * expand_ratio[self.backbones_type]), \
int(512 * expand_ratio[self.backbones_type])
self.fpn &＃61; FPN(C3_inplanes&＃61;C3_inplanes,
C4_inplanes&＃61;C4_inplanes,
C5_inplanes&＃61;C5_inplanes,
planes&＃61;self.planes)
self.cls_head &＃61; clsHead(inplanes&＃61;self.planes,
num_classes&＃61;self.num_classes)
self.reg_head &＃61; regHead(inplanes&＃61;self.planes)
self.anchors &＃61; Anchors()
self.regressBoxes &＃61; BBoxTransform()
self.clipBoxes &＃61; ClipBoxes()
self.loss &＃61; FocalLoss()
self.freeze_bn()
def freeze_bn(self):
&＃39;&＃39;&＃39;Freeze BatchNorm layers.&＃39;&＃39;&＃39;
for layer in self.modules():
if isinstance(layer, nn.BatchNorm2d):
layer.eval()
def forward(self, inputs):
if self.training:
img_batch, annots &＃61; inputs
# inference
else:
img_batch &＃61; inputs
[C3, C4, C5] &＃61; self.backbone(img_batch)
del inputs
features &＃61; self.fpn([C3, C4, C5])
del C3, C4, C5
# (batch_size, total_anchors_nums, num_classes)
cls_heads &＃61; torch.cat([self.cls_head(feature) for feature in features], dim&＃61;1)
# (batch_size, total_anchors_nums, 4)
reg_heads &＃61; torch.cat([self.reg_head(feature) for feature in features], dim&＃61;1)
del features
anchors &＃61; self.anchors(img_batch)
if self.training:
return self.loss(cls_heads, reg_heads, anchors, annots)
# inference
else:
transformed_anchors &＃61; self.regressBoxes(anchors, reg_heads)
transformed_anchors &＃61; self.clipBoxes(transformed_anchors, img_batch)
# scores
finalScores &＃61; torch.Tensor([])
# anchor id:0~79
finalAnchorBoxesIndexes &＃61; torch.Tensor([]).long()
# coordinates size:[...,4]
finalAnchorBoxesCoordinates &＃61; torch.Tensor([])
if torch.cuda.is_available():
finalScores &＃61; finalScores.cuda()
finalAnchorBoxesIndexes &＃61; finalAnchorBoxesIndexes.cuda()
finalAnchorBoxesCoordinates &＃61; finalAnchorBoxesCoordinates.cuda()
# num_classes
for i in range(cls_heads.shape[2]):
scores &＃61; torch.squeeze(cls_heads[:, :, i])
scores_over_thresh &＃61; (scores > 0.05)
if scores_over_thresh.sum() &＃61;&＃61; 0:
# no boxes to NMS, just continue
continue
scores &＃61; scores[scores_over_thresh]
anchorBoxes &＃61; torch.squeeze(transformed_anchors)
anchorBoxes &＃61; anchorBoxes[scores_over_thresh]
anchors_nms_idx &＃61; nms(anchorBoxes, scores, 0.5)
# use idx to find the scores of anchor
finalScores &＃61; torch.cat((finalScores, scores[anchors_nms_idx]))
# [0,0,0,...,1,1,1,...,79,79]
finalAnchorBoxesIndexesValue &＃61; torch.tensor([i] * anchors_nms_idx.shape[0])
if torch.cuda.is_available():
finalAnchorBoxesIndexesValue &＃61; finalAnchorBoxesIndexesValue.cuda()
finalAnchorBoxesIndexes &＃61; torch.cat((finalAnchorBoxesIndexes, finalAnchorBoxesIndexesValue))
# [...,4]
finalAnchorBoxesCoordinates &＃61; torch.cat((finalAnchorBoxesCoordinates, anchorBoxes[anchors_nms_idx]))
return finalScores, finalAnchorBoxesIndexes, finalAnchorBoxesCoordinates
if __name__ &＃61;&＃61; "__main__":
C &＃61; torch.randn([8, 3, 512, 512])
annot &＃61; torch.randn([8, 15, 5])
model &＃61; RetinaNet(backbones_type&＃61;"darknet19", num_classes&＃61;80, pretrained&＃61;True, training&＃61;True)
model &＃61; model.cuda()
C &＃61; C.cuda()
annot &＃61; annot.cuda()
model &＃61; torch.nn.DataParallel(model).cuda()
model.training &＃61; True
out &＃61; model([C, annot])
# if model.training &＃61;&＃61; True out&＃61;&＃61;loss
# out &＃61; model([C, annot])
# if model.training &＃61;&＃61; False out&＃61;&＃61; scores
# out &＃61; model(C)
for i in range(len(out)):
print(out[i])
# Scores: torch.Size([486449])
# tensor([4.1057, 4.0902, 4.0597, ..., 0.0509, 0.0507, 0.0507], device&＃61;&＃39;cuda:0&＃39;)
# Id: torch.Size([486449])
# tensor([ 0, 0, 0, ..., 79, 79, 79], device&＃61;&＃39;cuda:0&＃39;)
# loc: torch.Size([486449, 4])
# tensor([[ 45.1607, 249.4807, 170.5788, 322.8085],
# [ 85.9825, 324.4150, 122.9968, 382.6297],
# [148.1854, 274.0474, 179.0922, 343.4529],
# ...,
# [222.5421, 0.0000, 256.3059, 15.5591],
# [143.3349, 204.4784, 170.2395, 228.6654],
# [208.4509, 140.1983, 288.0962, 165.8708]], device&＃61;&＃39;cuda:0&＃39;)

使用此模型的评估结果&＃xff08;并非以上的DarkNet骨干网络&＃xff0c;而是自带的ResNet&＃xff09;&＃xff0c;未精细调节参数以及精度

模型评估VOC结果

Network: RetinaNet
backbone: ResNet50
neck: FPN
loss: Focal Loss
dataset: voc
batch_size: 4
optim: Adam
lr: 0.0001
scheduler: WarmupCosineSchedule
epoch: 80

模型voc可视化结果

模型评估COCO结果

Network: RetinaNet
backbone: ResNet50
neck: FPN
loss: Focal Loss
dataset: coco
batch_size: 4
optim: Adam
lr: 0.0001
scheduler: ReduceLROnPlateau
patience: 3
epoch: 30
pretrained: True

模型COCO可视化结果

若想知道更多代码详情&＃xff0c;请翻看我的gitHub!!

未完...

参考文献

[1] Redmon J, Farhadi A. YOLO9000: better, faster, stronger[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2017: 7263-7271.

[2] Redmon J, Farhadi A. Yolov3: An incremental improvement[J]. arXiv preprint arXiv:1804.02767, 2018.

[3] Lin T Y, Goyal P, Girshick R, et al. Focal loss for dense object detection[C]//Proceedings of the IEEE international conference on computer vision. 2017: 2980-2988.