devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SSD模型 （单发多框目标检测） 原理+代码

作者：笔触狂放9 | 2024-03-22 22:00:17

赞

踩

ssd模型

目录

二：单发多框检测（SSD）

三： 类别预测层

四：边界框预测层

连结多尺度的预测

为什么需要将通道数放在最后一维：

 高和宽减半块

​编辑如何计算感受野？

基本网络块

 完整的模型

​编辑

 SSD网络模型的锚框，类别概率，偏移量的全过程 

五：训练模型

读取数据集和初始化

定义损失函数和评价函数

训练模型

六： 预测目标

 七：小小总结

所有项目代码+UI界面

一：回顾  

      在前面的系列中，我们分别介绍了边界框、锚框、多尺度目标检测和用于目标检测的数据集。 现在我们已经准备好使用这样的背景知识来设计一个目标检测模型：单发多框检测（SSD）、、该模型简单、快速且被广泛使用。尽管这只是其中一种目标检测模型，但本节中的一些设计原则和实现细节也适用于其他模型。

二：单发多框检测（SSD）

        SSD:(单发多框检测（SSD）是一种用于目标检测的深度学习模型。"单发"指的是指单个神经网络在一次前向计算中同时预测多个目标的位置和类别，而"多框"指的是对于每个预测目标位置，它的主要思想是在整个图像上应用多个卷积层来预测不同尺度和长宽比的边界框，并通过非极大值抑制来获得最终的检测结果。SSD的优点是可以在较少的计算量下实现实时目标检测，并且可以检测不同尺度和长宽比的物体。

        图1描述了单发多框检测模型的设计。 此模型主要由基础网络组成，其后是几个多尺度特征块。 基本网络用于从输入图像中提取特征，因此它可以使用深度卷积神经网络。 单发多框检测论文中选用了在分类层之前截断的VGG (Liu et al., 2016)，现在也常用ResNet替代。 我们可以设计基础网络，使它输出的高和宽较大。 这样一来，基于该特征图生成的锚框数量较多，可以用来检测尺寸较小的目标。 接下来的每个多尺度特征块将上一层提供的特征图的高和宽缩小（如减半），并使特征图中每个单元在输入图像上的感受野变得更广阔。

                 图1、单发多框检测模型主要由一个基础网络块和若干多尺度特征块串联而成。

三： 类别预测层

        设目标类别的数量为q。这样一来，锚框有q+1个类别，其中0类是背景。 在某个尺度下，设特征图的高和宽分别为ℎ和w。 如果以其中每个单元为中心生成a个锚框，那么我们需要对ℎwa个锚框进行分类。 如果使用全连接层作为输出，很容易导致模型参数过多。 回忆 NiN一节介绍的使用卷积层的通道来输出类别预测的方法， 单发多框检测采用同样的方法来降低模型复杂度。

        在下面，我们定义了这样一个类别预测层，通过参数num_anchors和num_classes分别指定了a和q。 该图层使用填充为1的3×3的卷积层。此卷积层的输入和输出的宽度和高度保持不变。

  1. import torch
  2. #torchvision还提供了一些常见的模型架构，如VGG、ResNet、MobileNet等等，这些模型架构都是预训练好的，可以直接拿来进行微调或者特征提取
  3. # 等任务。
  4. #其中的datasets和transforms模块是用于数据预处理和数据增强的两个重要模块。
  5. import torchvision
  6. from torch import nn
  7. #如激活函数、池化函数、损失函数等
  8. # 它的特点是不保存状态，也就是说它的每个操作都是独立的，不需要像nn.Module那样要先进行初始化，也不需要像nn.Sequential
  9. #那样要先定义一连串的操作。
  10. # torch.nn.functional还提供了一些高级的优化方法，如自动求导、反向传播等，方便用户进行深度学习模型的训练和优化。
  11. from torch.nn import functional as F
  12. from d2l import torch as d2l
  13.  
  14. # 虽然直接将原始图片输入网络可以得到较大的输出特征图，但是这样做存在以下问题：计算复杂度过高,特征提取不充分,s所以需要卷积
  15. # 因此，一般来说，目标检测网络都会使用卷积层对原始图片进行特征提取，以获得更高效、更准确的检测结果。
  16. def cls_predictor(num_inputs, num_anchors, num_classes):
  17.     return nn.Conv2d(num_inputs, num_anchors * (num_classes + 1), 
  18.                      kernel_size=3, padding=1)#不管高宽是什么，最终还是输出什么！而且不会输出输入通道，输入通道只是进来而已，输出的是输出通道

四：边界框预测层

        边界框预测层的设计与类别预测层的设计类似。 唯一不同的是，这里需要为每个锚框预测4个偏移量，而不是q+1个类别。

  1. def bbox_predictor(num_inputs, num_anchors):  # 对每个边界框预测四个偏移量
  2.     return nn.Conv2d(num_inputs, num_anchors * 4, kernel_size=3, padding=1)

连结多尺度的预测

        正如我们所提到的，单发多框检测使用多尺度特征图来生成锚框并预测其类别和偏移量。 在不同的尺度下，特征图的形状或以同一单元为中心的锚框的数量可能会有所不同。 因此，不同尺度下预测输出的形状可能会有所不同。        

        在以下示例中，我们为同一个小批量构建两个不同比例（Y1和Y2）的特征图，其中Y2的高度和宽度是Y1的一半。 以类别预测为例，假设Y1和Y2的每个单元分别生成了5个和3个锚框。 进一步假设目标类别的数量为10，对于特征图Y1和Y2，类别预测输出中的通道数分别为5×(10+1)=55和3×(10+1)=33，其中任一输出的形状是（批量大小，通道数，高度，宽度）。​

正如我们所看到的，除了批量大小这一维度外，其他三个维度都具有不同的尺寸。 为了将这两个预测输出链接起来以提高计算效率，我们将把这些张量转换为更一致的格式。

        通道维包含中心相同的锚框的预测结果。我们首先将通道维移到最后一维。 因为不同尺度下批量大小仍保持不变，我们可以将预测结果转成二维的（批量大小，高×宽×通道数）的格式，以方便之后在维度1上的连结。

为什么需要将通道数放在最后一维：

        确实，结果上是一样的，无论通道维度在第一维还是在最后一维，张量的数值和形状都是一样的。但是，将通道维度放在最后维的好处是，能够更好地利用现代CPU和GPU的高速缓存机制，减少访问内存的次数，提高计算效率，这是因为现代处理器在访问内存时，往往会先将内存中的一块数据加载到缓存中，然后再进行操作。如果张量的低维度(如高度、宽度)在内存中是连续的，那么加载到缓存中的数据块会更大厂命中缓存的概率就会更高，提高了计算效率。而将通道维度放在最后一维，可以更好地满足这个连续性要求。因此，将通道维度放在最后一维是一种更为优化的做法。

  1. # 为了不同尺度下批量大小仍保持不变，我们可以将预测结果转成二维的（批量大小，高宽通道数）的格式，以方便之后在维度上的连结。
  2. def flatten_pred(pred):
  3.     # 批量维度不变，2，3位表示像素高宽，1表示通道数：5个框所预测的类别数（5*11），这样拉直之后同一个像素的框所判断的类是集中在一起的
  4.     return torch.flatten(pred.permute(0, 2, 3, 1), start_dim=1)  # start_dim参数表示开始拉平的维度
  5.  
  6.  
  7. def concat_preds(preds):
  8.     return torch.cat([flatten_pred(p) for p in preds], dim=1)
  9.     # 展平后变成了(2, 880),展平后变成了(2, 132),dim=1在第二个维度（通道数）上进行拼接，所以最终的形状是(2, 880+132)=(2, 1012)。
  10.  
  11.  
  12. print(concat_preds([Y1, Y2]).shape)

        这样一来，尽管Y1和Y2在通道数、高度和宽度方面具有不同的大小，我们仍然可以在同一个小批量的两个不同尺度上连接这两个预测输出。

 高和宽减半块

        为了在多个尺度下检测目标，我们在下面定义了高和宽减半块down_sample_blk，该模块将输入特征图的高度和宽度减半。 事实上，该块应用了在 subsec_vgg-blocks中的VGG模块设计。 更具体地说，每个高和宽减半块由两个填充为1的3×3的卷积层、以及步幅为2的2×2最大汇聚层组成。 我们知道，填充为1的3×3卷积层不改变特征图的形状。但是，其后的2×2的最大汇聚层将输入特征图的高度和宽度减少了一半。 对于此高和宽减半块的输入和输出特征图，因为1×2+(3−1)+(3−1)=6，所以输出中的每个单元在输入上都有一个6×6的感受野。因此，高和宽减半块会扩大每个单元在其输出特征图中的感受野。

  1. # 每个高和宽减半块由两个填充为1的3*3的卷积层、以及步幅为2的2*2最大汇聚层组成
  2. # 我们知道，填充为的卷积层不改变特征图的形状
  3. def down_sample_blk(in_channels, out_channels):
  4.     blk = []
  5.     for _ in range(2):#这个数字不影响，3*3pading是1，卷多少次还是一样，主要是看最大池化层
  6.         blk.append(nn.Conv2d(in_channels, out_channels,
  7.                              kernel_size=3, padding=1))  # 图像大小没变，但是特征好像提取出来了（是的，越深语义信息越强）
  8.         blk.append(nn.BatchNorm2d(out_channels))
  9.         blk.append(nn.ReLU())
  10.         in_channels = out_channels
  11.     blk.append(nn.MaxPool2d(2))  # dilation 参数表示卷积核中每个元素之间的间隔大小。默认值为1
  12.     return nn.Sequential(*blk)
  13.  
  14.  
  15. print(forward(torch.zeros((2, 3, 20, 20)), down_sample_blk(3, 10)).shape)  # 通道数不变的话，循环几次结果都不会变的，必须通过改变通道数来改变高宽的大小
  16. down_sample_blk(3, 10)  # 用公式可得出结果：torch.Size([2, 10, 10, 10])

如何计算感受野？

        在卷积神经网络中，感受野（Receptive Field）的定义是卷积神经网络每一层输出的特征图（feature map）上的像素点在输入图片上映射的区域大小。再通俗点的解释是，特征图上的一个点对应输入图上的区域，如图。

1、 感受野计算公式：

F(i)=[ F(i+1)-1 ] * Stride + KSize （注意看上面的图，这里把最下面看作第一层，然后依次往上递增）

F(i)表示第i层感受野
Stride为第i层步距,影响输出宽高
KSize为卷积核或者池化核的尺寸

2、以VGG网络为例，为什么两个3x3的卷积核可以替换一个5x5的卷积核，3个3x3的卷积核可以替换一个7x7的卷积核？这可以用感受野解释

3、有时候使用小的3x3卷积核堆叠，也可以有效的减少参数，这里和7x7卷积核做个对比

假设输入和输出的 channel 为 C，分别计算所需参数：

7x7卷积核 ：7x7xCxC=49C^2
3个3x3卷积核 ：3x3xCxC + 3x3xCxC + 3x3xCxC = 27C^2 (明显减少)

基本网络块

        基本网络块用于从输入图像中抽取特征。 为了计算简洁，我们构造了一个小的基础网络，该网络串联3个高和宽减半块，并逐步将通道数翻倍。 给定输入图像的形状为256×256，此基本网络块输出的特征图形状为32×32（256/2的三次方=32）。

 完整的模型

        完整的单发多框检测模型由五个模块组成。每个块生成的特征图既用于生成锚框，又用于预测这些锚框的类别和偏移量。在这五个模块中，第一个是基本网络块，第二个到第四个是高和宽减半块，最后一个模块使用全局最大池将高度和宽度都降到1。从技术上讲，第二到第五个区块都是图2 中的多尺度特征块。        

                                                                         图2

  1. def get_blk(i):
  2.     if i == 0:
  3.         blk = base_net()  # 基本网络块用于从输入图像中抽取特征,原图256*256，处理后生成的就是featuremap了，这里featuremap是32*32
  4.     elif i == 1:
  5.         blk = down_sample_blk(64, 128)  # 第二个到第四个是高和宽减半块
  6.     elif i == 4:
  7.         blk = nn.AdaptiveMaxPool2d((1, 1))  # 自适应，每个通道内的最大像素值，类似于全局汇聚成，代替了全连接层，这样做可以大量减少计算量
  8.     else:
  9.         blk = down_sample_blk(128, 128)
  10.     return blk

        现在我们为每个块定义前向传播。与图像分类任务不同，此处的输出包括：CNN特征图Y；在当前尺度下根据Y生成的锚框；预测的这些锚框的类别和偏移量（基于Y）。

  1. # 输入Y是经过backbone后的图片
  2. def blk_forward(X, blk, size, ratio, cls_predictor, bbox_predictor):
  3.     Y = blk(X)  # 特征图
  4.     print('Y的形状是什么？:',Y.shape)
  5.     # 对于Y：我只需要你的h和w，你的数值是什么batch，通道这些我都不关心，我只要h和w
  6.     anchors = d2l.multibox_prior(Y, sizes=size, ratios=ratio)  # 这一行跟之前讲解的的生成锚框那章节是一样的，生成每个像素点的锚框，boxes_per_pixel在库函数定义
  7.     print('anchors的形状是什么？:',anchors.shape)
  8.     cls_preds = cls_predictor(Y)
  9.     bbox_preds = bbox_predictor(Y)
  10.     return (Y, anchors, cls_preds, bbox_preds) #Y返回回去就是叫X

        回想一下，在图2中，一个较接近顶部的多尺度特征块是用于检测较大目标的，因此需要生成更大的锚框。 在上面的前向传播中，在每个多尺度特征块上，我们通过调用的multibox_prior函数（见之前的生成锚框的章节）的sizes参数传递两个比例值的列表。 在下面，0.2和1.05之间的区间被均匀分成五个部分，以确定五个模块的在不同尺度下的较小值：0.2、0.37、0.54、0.71和0.88。 之后，他们较大的值由根号（0.2×0.37）=0.272、根号（0.37×0.54）=0.447等给出。

  1. sizes = [[0.2, 0.272], [0.37, 0.447], [0.54, 0.619], [0.71, 0.79],
  2.          [0.88, 0.961]]
  3. ratios = [[1, 2, 0.5]] * 5
  4. num_anchors = len(sizes[0])+ len(ratios[0]) - 1
  5. print(num_anchors)
  6. len(sizes[0]),len(ratios[0])
  7.  
  8. 输出：
  9. 4
  10. (2, 3)

现在，我们就可以按如下方式定义完整的模型TinySSD了。

 输入图片的大小是：

  1. X = torchvision.io.read_image('5.jpeg').unsqueeze(0).float()
  2. print(X.shape)#torch.Size([1, 3, 256, 256])

 SSD网络模型的锚框，类别概率，偏移量的全过程 

我们创建一个模型实例，然后使用它对一个256×256像素的小批量图像X执行前向传播。

        如本节前面部分所示，第一个模块输出特征图的形状为32×32。 回想一下，第二到第四个模块为高和宽减半块，第五个模块为全局汇聚层。 由于以特征图的每个单元为中心有4个锚框生成，因此在所有五个尺度下，每个图像总共生成(32^2+16^2+8^2+4^2+1)×4=5444个锚框。

五：训练模型

现在，我们将描述如何训练用于目标检测的单发多框检测模型。

读取数据集和初始化

  1. batch_size = 32
  2. train_iter, _ = d2l.load_data_bananas(batch_size)
  3.  
  4. #香蕉检测数据集中，目标的类别数为1。 定义好模型后，我们需要初始化其参数并定义优化算法。
  5. device, net = d2l.try_gpu(), TinySSD(num_classes=1)
  6.  
  7. trainer = torch.optim.SGD(net.parameters(), lr=0.2, weight_decay=5e-4)

定义损失函数和评价函数

        目标检测有两种类型的损失。 第一种有关锚框类别的损失：我们可以简单地复用之前图像分类问题里一直使用的交叉熵损失函数来计算； 第二种有关正类锚框偏移量的损失：预测偏移量是一个回归问题。 但是，对于这个回归问题，我们在这里不使用平方损失，而是使用L1范数损失，即预测值和真实值之差的绝对值。 掩码变量bbox_masks令负类锚框和填充锚框不参与损失的计算。 最后，我们将锚框类别和偏移量的损失相加，以获得模型的最终损失函数。

        我们可以沿用准确率评价分类结果。 由于偏移量使用了L1范数损失，我们使用平均绝对误差来评价边界框的预测结果。这些预测结果是从生成的锚框及其预测偏移量中获得的。

  1. #************************************************************************************************************************************
  2.  
  3. #                  评估模型
  4.  
  5. #************************************************************************************************************************************
  6.  
  7. # 我们可以沿用准确率评价分类结果。 由于偏移量使用了范数损失，我们使用平均绝对误差来评价边界框的预测结果。
  8. # 这些预测结果是从生成的锚框及其预测偏移量中获得的。
  9. def cls_eval(cls_preds, cls_labels):
  10.     # 由于类别预测结果放在最后一维，argmax需要指定最后一维。
  11.     #cls_preds是模型的分类预测结果，每一行代表一组预测结果。cls_labels是真实的分类标签，代表了每一组数据的真实类别。
  12.     return float((cls_preds.argmax(dim=-1).type(
  13.         cls_labels.dtype) == cls_labels).sum())
  14.     #最大的概率是真实概率，说明预测成功，返回正类样本的总数，计算准确率
  15.  
  16. def bbox_eval(bbox_preds, bbox_labels, bbox_masks):
  17.     return float((torch.abs((bbox_labels - bbox_preds) * bbox_masks)).sum())#返回总的平移量，（掩码值为0的元素对应的损失不计入总损失）

训练模型

        在训练模型时，我们需要在模型的前向传播过程中生成多尺度锚框（anchors），并预测其类别（cls_preds）和偏移量（bbox_preds）。 然后，我们根据标签信息Y为生成的锚框标记类别（cls_labels）和偏移量（bbox_labels）。 最后，我们根据类别和偏移量的预测和标注值计算损失函数。为了代码简洁，这里没有评价测试数据集。

  1. #************************************************************************************************************************************
  2.  
  3. #                   训练模型
  4.  
  5. #************************************************************************************************************************************
  6. # 在训练模型时，我们需要在模型的前向传播过程中生成多尺度锚框（anchors），并预测其类别（cls_preds）和偏移量（bbox_preds）。
  7. # 然后，我们根据标签信息Y为生成的锚框标记类别（cls_labels）和偏移量（bbox_labels）。
  8. # 最后，我们根据类别和偏移量的预测和标注值计算损失函数。为了代码简洁，这里没有评价测试数据集。
  9. num_epochs, timer = 20, d2l.Timer()
  10. animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
  11.                         legend=['class error', 'bbox mae'])
  12. net = net.to(device)
  13. for epoch in range(num_epochs):
  14.     # 训练精确度的和，训练精确度的和中的示例数
  15.     # 绝对误差的和，绝对误差的和中的示例数
  16.     metric = d2l.Accumulator(4)#Accumulator 是一个自定义的简单类，用于在每个时期跟踪度量的值
  17.     net.train()#net.train()是一个函数，用于设置模型为训练模式，在训练模式下，PyTorch会自动跟踪这些信息，而在测试/评估阶段，我们需要使用预先计算的统计信息来标准化输入，因此要将模型切换到eval模式。
  18.     # 它的每个迭代返回一个形状为 (batch_size, 3, 224, 224) 的小批量图像数据和形状为 (batch_size,) 的小批量标签数据。
  19.     for features, target in train_iter:
  20.         timer.start()
  21.         trainer.zero_grad()
  22.         X, Y = features.to(device), target.to(device)
  23.         # print(features.shape)#torch.Size([32, 3, 256, 256])
  24.         # print(target.shape)#torch.Size([32, 1, 5])
  25.         
  26.         # 这些都是类似w权重，先初始化后待训练的
  27.         anchors, cls_preds, bbox_preds = net(X) #这里有个生成锚框的函数，然后生成的anchors再传到multibox_target计算偏移量。
  28.         # print(anchors.shape) #torch.Size([1, 5444, 4]) 5444是多层卷积cat后的结果
  29.         
  30.         # 这些都是类似与真实变量，与上面的做损失
  31.         bbox_labels, bbox_masks, cls_labels = d2l.multibox_target(anchors, Y)#这里面有iou，assign_gtbox_to_anchor函数（现在1-4都用上了）
  32.         # print(bbox_masks.shape)#torch.Size([32, 21776]) 5444*4
  33.         # print(bbox_labels.shape) torch.Size([32, 21776]) 5444*4 ,baitch和返回个数
  34.         # print(cls_labels.shape)  torch.Size([32, 5444])batch和返回个数 就是那个ture个数也是锚框的行数！

六： 预测目标

        在预测阶段，我们希望能把图像里面所有我们感兴趣的目标检测出来。在下面，我们读取并调整测试图像的大小，然后将其转成卷积层需要的四维格式。

        使用下面的multibox_detection函数，我们可以根据锚框及其预测偏移量得到预测边界框。然后，通过非极大值抑制来移除相似的预测边界框。

# BatchNormalization层在evaluation模式下不再计算移动平均和移动方差，# Dropout层在evaluation模式下不再丢弃神经元，而是保留所有神经元，

  1. #************************************************************************************************************************************
  2.  
  3. #                   预测目标
  4.  
  5. #************************************************************************************************************************************
  6. # 在预测阶段，我们希望能把图像里面所有我们感兴趣的目标检测出来。在下面，我们读取并调整测试图像的大小，然后将其转成卷积层需要的四维格式
  7. X = torchvision.io.read_image('5.jpeg').unsqueeze(0).float()
  8. print(X.shape)#torch.Size([1, 3, 256, 256])
  9. img = X.squeeze(0).permute(1, 2, 0).long()#李沐的显示图片要变成（h，w，c）
  10.  
  11. # 使用下面的multibox_detection函数，我们可以根据锚框及其预测偏移量得到预测边界框。然后，通过非极大值抑制来移除相似的预测边界框
  12. def predict(X):
  13.     net.eval()
  14.     # 是用于将神经网络切换到evaluation模式的函数。在这个模式下，网络的行为与训练模式不同，主要有两个方面
  15.     # BatchNormalization层在evaluation模式下不再计算移动平均和移动方差，而是使用训练好的固定值，以确保在不同的数据batch之间结果的一致性。
  16.     # Dropout层在evaluation模式下不再丢弃神经元，而是保留所有神经元，并乘以一个与训练时丢弃概率相等的常数，以保证输出的期望值与在训练时相同。
  17.     
  18.     anchors, cls_preds, bbox_preds = net(X.to(device))#预测的时候,里面有个类似于学习好的w,会让你的输出比较接近真实框，偏移量比较相似
  19.     # print('吉姆餐厅：',cls_preds.shape)#torch.Size([1, 5444, 2])
  20.     cls_probs = F.softmax(cls_preds, dim=2).permute(0, 2, 1)
  21.     output = d2l.multibox_detection(cls_probs, bbox_preds, anchors)#cls_preds变成概率传进去nms
  22.     # print(output[0])#tensor([[ 0.0000,  0.4956,  0.1899, -0.1307,  0.8356,  1.1496],...... [-1.0000,  0.3872, -0.0113,  0.0612,  0.9794,  0.9674]],
  23.     # print(output.shape)#torch.Size([1, 5444, 6])
  24.     idx = [i for i, row in enumerate(output[0]) if row[0] != -1]#row[0] != -1负类或者背景类，判断预测框是否为有效框的。
  25. #     print(len(output[0]))#5444
  26. #     print(idx)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21......................
  27. #     print(output[0, idx])#tensor([[ 0.0000,  0.4956,  0.1899, -0.1307,  0.8356,  1.1496],.......[ 0.0000,  0.0102,  0.1773,  0.6717,  0.4459,  0.9288]],
  28.     return output[0, idx]
  29.  
  30. output = predict(X)

最后，我们筛选所有置信度不低于0.9的边界框，做为最终输出。

 Threshold不一样，库函数的nms的iou应该是不大，重合的还是很多，不过用threshold限制也可以。

 

 七：小小总结

        每一层的结果并不是网络经过训练得到的预测结果，而是利用已经训练好的模型进行前向传播得到的中间结果。

        在目标检测中，SSD模型通过在不同尺度和长宽比的特征图上应用卷积操作，生成一系列的锚框。然后，利用这些锚框与真实标注框之间的IoU（交并比）进行筛选，确定每个锚框的正负样本，并计算它们的偏移量。

        所以，在上面给的代码中，每一层卷积的结果是通过利用IoU筛选锚框并计算偏移量得到的。这些结果是在单次前向传播过程中生成的，而不是通过训练过程获得的网络预测结果。

        网络的训练通常是在每一轮的所有卷积计算完成后进行的。在训练过程中，模型根据预测结果和真实标注进行损失计算和反向传播，然后更新模型参数。所以，在每一轮训练的最后才会进行损失的计算和优化。

        因此，每一层的卷积操作会对偏移量和类别分别进行预测，这些预测结果会用于后续的损失计算和优化过程。

所有项目代码+UI界面

视频，笔记和代码,以及注释都已经上传网盘，放在主页置顶文章

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/291182
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号