""" YoloV3 模型的基本组件 import paddle import paddle.nn.functional as F class…
- User
"""
YoloV3 模型的基本组件
import paddle import paddle.nn.functional as F
class ConvBNLayer(paddle.nn.Layer): def init(self, ch_in, ch_out, kernel_size=3, stride=1, groups=1, padding=0, act="leaky"): super(ConvBNLayer, self).init()
self.conv = paddle.nn.Conv2D( in_channels=ch_in, out_channels=ch_out, kernel_size=kernel_size, stride=stride, padding=padding, groups=groups, weight_attr=paddle.ParamAttr( initializer=paddle.nn.initializer.Normal(0., 0.02)), bias_attr=False) self.batch_norm = paddle.nn.BatchNorm2D( num_features=ch_out, weight_attr=paddle.ParamAttr( initializer=paddle.nn.initializer.Normal(0., 0.02), regularizer=paddle.regularizer.L2Decay(0.)), bias_attr=paddle.ParamAttr( initializer=paddle.nn.initializer.Constant(0.0), regularizer=paddle.regularizer.L2Decay(0.))) self.act = act def forward(self, inputs): out = self.conv(inputs) out = self.batch_norm(out) if self.act == 'leaky': out = F.leaky_relu(x=out, negative_slope=0.1) return outclass DownSample(paddle.nn.Layer): # 下采样,图片尺寸减半,具体实现方式是使用stirde=2的卷积 def init(self, ch_in, ch_out, kernel_size=3, stride=2, padding=1):
super(DownSample, self).__init__() self.conv_bn_layer = ConvBNLayer( ch_in=ch_in, ch_out=ch_out, kernel_size=kernel_size, stride=stride, padding=padding) self.ch_out = ch_out def forward(self, inputs): out = self.conv_bn_layer(inputs) return outclass BasicBlock(paddle.nn.Layer): """ 基本残差块的定义,输入x经过两层卷积,然后接第二层卷积的输出和输入x相加 """ def init(self, ch_in, ch_out): super(BasicBlock, self).init()
self.conv1 = ConvBNLayer( ch_in=ch_in, ch_out=ch_out, kernel_size=1, stride=1, padding=0 ) self.conv2 = ConvBNLayer( ch_in=ch_out, ch_out=ch_out*2, kernel_size=3, stride=1, padding=1 ) def forward(self, inputs): conv1 = self.conv1(inputs) conv2 = self.conv2(conv1) out = paddle.add(x=inputs, y=conv2) return outclass LayerWarp(paddle.nn.Layer): """ 添加多层残差块,组成Darknet53网络的一个层级 """ def init(self, ch_in, ch_out, count, is_test=True): super(LayerWarp,self).init()
self.basicblock0 = BasicBlock(ch_in, ch_out) self.res_out_list = [] for i in range(1, count): res_out = self.add_sublayer("basic_block_%d" % (i), # 使用add_sublayer添加子层 BasicBlock(ch_out*2, ch_out)) self.res_out_list.append(res_out) def forward(self,inputs): y = self.basicblock0(inputs) for basic_block_i in self.res_out_list: y = basic_block_i(y) return yDarkNet 每组残差块的个数,来自DarkNet的网络结构图
DarkNet_cfg = {53: ([1, 2, 8, 8, 4])} class DarkNet53_conv_body(paddle.nn.Layer): def init(self): super(DarkNet53_conv_body, self).init() self.stages = DarkNet_cfg[53] self.stages = self.stages[0:5]
# 第一层卷积 self.conv0 = ConvBNLayer( ch_in=3, ch_out=32, kernel_size=3, stride=1, padding=1) # 下采样,使用stride=2的卷积来实现 self.downsample0 = DownSample( ch_in=32, ch_out=32 * 2) # 添加各个层级的实现 self.darknet53_conv_block_list = [] self.downsample_list = [] for i, stage in enumerate(self.stages): conv_block = self.add_sublayer( "stage_%d" % (i), LayerWarp(32*(2**(i+1)), 32*(2**i), stage)) self.darknet53_conv_block_list.append(conv_block) # 两个层级之间使用DownSample将尺寸减半 for i in range(len(self.stages) - 1): downsample = self.add_sublayer( "stage_%d_downsample" % i, DownSample(ch_in=32*(2**(i+1)), ch_out=32*(2**(i+2)))) self.downsample_list.append(downsample) def forward(self,inputs): out = self.conv0(inputs) #print("conv1:",out.numpy()) out = self.downsample0(out) #print("dy:",out.numpy()) blocks = [] for i, conv_block_i in enumerate(self.darknet53_conv_block_list): #依次将各个层级作用在输入上面 out = conv_block_i(out) blocks.append(out) if i < len(self.stages) - 1: out = self.downsample_list[i](out) return blocks[-1:-4:-1] # 将C0, C1, C2作为返回值Yolo检测头,指定输出P0、P1或P2特征
class YoloDetectionBlock(paddle.nn.Layer): # define YOLOv3 detection head # 使用多层卷积和BN提取特征 def init(self,ch_in,ch_out,is_test=True): super(YoloDetectionBlock, self).init()
assert ch_out % 2 == 0, \ "channel {} cannot be divided by 2".format(ch_out) self.conv0 = ConvBNLayer( ch_in=ch_in, ch_out=ch_out, kernel_size=1, stride=1, padding=0) self.conv1 = ConvBNLayer( ch_in=ch_out, ch_out=ch_out*2, kernel_size=3, stride=1, padding=1) self.conv2 = ConvBNLayer( ch_in=ch_out*2, ch_out=ch_out, kernel_size=1, stride=1, padding=0) self.conv3 = ConvBNLayer( ch_in=ch_out, ch_out=ch_out*2, kernel_size=3, stride=1, padding=1) self.route = ConvBNLayer( ch_in=ch_out*2, ch_out=ch_out, kernel_size=1, stride=1, padding=0) self.tip = ConvBNLayer( ch_in=ch_out, ch_out=ch_out*2, kernel_size=3, stride=1, padding=1) def forward(self, inputs): out = self.conv0(inputs) out = self.conv1(out) out = self.conv2(out) out = self.conv3(out) route = self.route(out) tip = self.tip(route) return route, tip定义上采样模块
class Upsample(paddle.nn.Layer): def init(self, scale=2): super(Upsample,self).init() self.scale = scale
def forward(self, inputs): # get dynamic upsample output shape shape_nchw = paddle.shape(inputs) shape_hw = paddle.slice(shape_nchw, axes=[0], starts=[2], ends=[4]) shape_hw.stop_gradient = True in_shape = paddle.cast(shape_hw, dtype='int32') out_shape = in_shape * self.scale out_shape.stop_gradient = True # reisze by actual_shape out = paddle.nn.functional.interpolate( x=inputs, scale_factor=self.scale, mode="NEAREST") return out定义YOLOv3模型
class YOLOv3(paddle.nn.Layer): def init(self, num_classes=7): super(YOLOv3,self).init()
self.num_classes = num_classes # 提取图像特征的骨干代码 self.block = DarkNet53_conv_body() self.block_outputs = [] self.yolo_blocks = [] self.route_blocks_2 = [] # 生成3个层级的特征图P0, P1, P2 for i in range(3): # 添加从ci生成ri和ti的模块 yolo_block = self.add_sublayer( "yolo_detecton_block_%d" % (i), YoloDetectionBlock( ch_in=512//(2**i)*2 if i==0 else 512//(2**i)*2 + 512//(2**i), ch_out = 512//(2**i))) self.yolo_blocks.append(yolo_block) num_filters = 3 * (self.num_classes + 5) # 添加从ti生成pi的模块,这是一个Conv2D操作,输出通道数为3 * (num_classes + 5) block_out = self.add_sublayer( "block_out_%d" % (i), paddle.nn.Conv2D(in_channels=512//(2**i)*2, out_channels=num_filters, kernel_size=1, stride=1, padding=0, weight_attr=paddle.ParamAttr( initializer=paddle.nn.initializer.Normal(0., 0.02)), bias_attr=paddle.ParamAttr( initializer=paddle.nn.initializer.Constant(0.0), regularizer=paddle.regularizer.L2Decay(0.)))) self.block_outputs.append(block_out) if i < 2: # 对ri进行卷积 route = self.add_sublayer("route2_%d"%i, ConvBNLayer(ch_in=512//(2**i), ch_out=256//(2**i), kernel_size=1, stride=1, padding=0)) self.route_blocks_2.append(route) # 将ri放大以便跟c_{i+1}保持同样的尺寸 self.upsample = Upsample() def forward(self, inputs): outputs = [] blocks = self.block(inputs) for i, block in enumerate(blocks): if i > 0: # 将r_{i-1}经过卷积和上采样之后得到特征图,与这一级的Ci进行拼接 block = paddle.concat([route, block], axis=1) # 从ci生成ti和ri route, tip = self.yolo_blocks[i](block) # 从ti生成pi block_out = self.block_outputs[i](tip) # 将pi放入列表 outputs.append(block_out) if i < 2: # 对ri进行卷积调整通道数 route = self.route_blocks_2[i](route) # 对ri进行放大,使其尺寸和c_{i+1}保持一致 route = self.upsample(route) return outputs def get_loss(self, outputs, gtbox, gtlabel, gtscore=None, anchors = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326], anchor_masks = [[6, 7, 8], [3, 4, 5], [0, 1, 2]], ignore_thresh=0.7, use_label_smooth=False): """ 使用paddle.vision.ops.yolo_loss,直接计算损失函数,过程更简洁,速度也更快 """ self.losses = [] downsample = 32 for i, out in enumerate(outputs): # 对三个层级分别求损失函数 anchor_mask_i = anchor_masks[i] loss = paddle.vision.ops.yolo_loss( x=out, # out是P0, P1, P2中的一个 gt_box=gtbox, # 真实框坐标 gt_label=gtlabel, # 真实框类别 gt_score=gtscore, # 真实框得分,使用mixup训练技巧时需要,不使用该技巧时直接设置为1,形状与gtlabel相同 anchors=anchors, # 锚框尺寸,包含[w0, h0, w1, h1, ..., w8, h8]共9个锚框的尺寸 anchor_mask=anchor_mask_i, # 筛选锚框的mask,例如anchor_mask_i=[3, 4, 5],将anchors中第3、4、5个锚框挑选出来给该层级使用 class_num=self.num_classes, # 分类类别数 ignore_thresh=ignore_thresh, # 当预测框与真实框IoU > ignore_thresh,标注objectness = -1 downsample_ratio=downsample, # 特征图相对于原图缩小的倍数,例如P0是32, P1是16,P2是8 use_label_smooth=False) # 使用label_smooth训练技巧时会用到,这里没用此技巧,直接设置为False self.losses.append(paddle.mean(loss)) #mean对每张图片求和 downsample = downsample // 2 # 下一级特征图的缩放倍数会减半 return sum(self.losses) # 对每个层级求和 def get_pred(self, outputs, im_shape=None, anchors = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326], anchor_masks = [[6, 7, 8], [3, 4, 5], [0, 1, 2]], valid_thresh = 0.01): downsample = 32 total_boxes = [] total_scores = [] for i, out in enumerate(outputs): anchor_mask = anchor_masks[i] anchors_this_level = [] for m in anchor_mask: anchors_this_level.append(anchors[2 * m]) anchors_this_level.append(anchors[2 * m + 1]) boxes, scores = paddle.vision.ops.yolo_box( x=out, img_size=im_shape, anchors=anchors_this_level, class_num=self.num_classes, conf_thresh=valid_thresh, downsample_ratio=downsample, name="yolo_box" + str(i)) total_boxes.append(boxes) total_scores.append( paddle.transpose( scores, perm=[0, 2, 1])) downsample = downsample // 2 yolo_boxes = paddle.concat(total_boxes, axis=1) yolo_scores = paddle.concat(total_scores, axis=2) return yolo_boxes, yolo_scores""" 这份代码是麦穗检测里的YOLOv3模型,可以告诉我这份代码的每一行在做什么吗?我对YOLO模型一无所知,请尽量详细一些,必要的话可以推荐一些较短的视频给我入门。请注意,代码使用的是paddle库,然而我最终会使用pytorch库进行项目构建,所以对于其中paddle库和pytorch库中用法不同的地方,希望你也能对这些地方进行说明,讲讲如果使用pytorch库应该怎么做
- Assistant
这段代码实现了一个用于麦穗检测的YOLOv3模型。YOLOv3(You Only Look Once v3)是一种实时物体检测方法。它是一种单阶段算法,同时具有较高的准确性和性能。下面是代码的详细分析:
代码首先定义了几个模块,这些模块在YOLOv3中发挥作用,它们是:
-
ConvBNLayer:一个由卷积层(Conv2D)和批量归一化层(BatchNorm2D)组成的模块。在某些情况下还使用了Leaky ReLU激活函数。
-
DownSample:用于对图像进行下采样的模块,将图像尺寸减小一半。实现方式是使用stride为2的卷积。
-
BasicBlock:定义了YOLOv3中Darknet中的基本残差块。输入x经过两层卷积后,再与输入x相加,形成残差块。
-
LayerWarp:通过将多个残差块堆叠在一起,组成Darknet53网络的一个层级。
-
DarkNet53_conv_body:提取图像特征的DarkNet53骨干网络部分。将输入图像传递到Darknet53网络中,返回3个尺度的特征图。
-
YoloDetectionBlock:YOLO检测头,负责提取每个YOLO尺度的特征。
-
Upsample:定义了一个上采样模块,用于将特征图尺寸扩大,使得高级特征图可以与低级特征图融合。
-
YOLOv3:定义了用于麦穗检测的YOLOv3模型。使用DarkNet53作为骨干网络,将提取到的特征图传递给多个检测头,并为每个yolo尺度生成预测输出。
-
get_loss:定义了计算YOLOv3损失函数的方法。损失函数包括坐标损失、类别损失和置信度损失。
-
get_pred:定义了根据给定的阈值对YOLOv3输出进行后处理并生成目标检测结果的方法。
关于在PyTorch中构建类似模型的说明,以下是对paddle和PyTorch中用法不同的地方的解释。
Paddle: paddle.nn.Layer PyTorch: torch.nn.Module 在Pytorch中,自定义的模型和层应继承自
torch.nn.Module而不是paddle.nn.Layer。Paddle: paddle.nn.functional.interpolate PyTorch: torch.nn.functional.interpolate
虽然两个库的函数在作用上大致相同,但在PyTorch中,您需要将输入图像reshape为 [batch, channel, height, width] 以适应函数的要求。
Paddle: paddle.vision.ops.yolo_loss 和 paddle.vision.ops.yolo_box PyTorch: torchvision.ops.box_iou 和 torchvision.ops.nms (或寻找第三方实现)
在PyTorch中,您可以使用
torchvision.ops.box_iou计算IoU损失,并使用torchvision.ops.nms实现非极大值抑制。Yolo损失和Yolo box操作没有内置函数,但您可以参考一些GitHub实现代码来完成相应的功能。 -