Skip to content
The Chat Archive
gpt-4-0314· OpenAI WildChat-4.8M (AI2)

""" YoloV3 模型的基本组件 import paddle import paddle.nn.functional as F class…

  1. 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 out
    

    class 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 out
    

    class 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 out
    
     
    

    class 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 y
    

    DarkNet 每组残差块的个数,来自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库应该怎么做

  2. Assistant

    这段代码实现了一个用于麦穗检测的YOLOv3模型。YOLOv3(You Only Look Once v3)是一种实时物体检测方法。它是一种单阶段算法,同时具有较高的准确性和性能。下面是代码的详细分析:

    代码首先定义了几个模块,这些模块在YOLOv3中发挥作用,它们是:

    1. ConvBNLayer:一个由卷积层(Conv2D)和批量归一化层(BatchNorm2D)组成的模块。在某些情况下还使用了Leaky ReLU激活函数。

    2. DownSample:用于对图像进行下采样的模块,将图像尺寸减小一半。实现方式是使用stride为2的卷积。

    3. BasicBlock:定义了YOLOv3中Darknet中的基本残差块。输入x经过两层卷积后,再与输入x相加,形成残差块。

    4. LayerWarp:通过将多个残差块堆叠在一起,组成Darknet53网络的一个层级。

    5. DarkNet53_conv_body:提取图像特征的DarkNet53骨干网络部分。将输入图像传递到Darknet53网络中,返回3个尺度的特征图。

    6. YoloDetectionBlock:YOLO检测头,负责提取每个YOLO尺度的特征。

    7. Upsample:定义了一个上采样模块,用于将特征图尺寸扩大,使得高级特征图可以与低级特征图融合。

    8. YOLOv3:定义了用于麦穗检测的YOLOv3模型。使用DarkNet53作为骨干网络,将提取到的特征图传递给多个检测头,并为每个yolo尺度生成预测输出。

    9. get_loss:定义了计算YOLOv3损失函数的方法。损失函数包括坐标损失、类别损失和置信度损失。

    10. 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实现代码来完成相应的功能。