【YOLOv7_0.1】网络结构与源码解析

2023年7月29日上午8:42 • 人工智能 • 阅读 59

文章目录

前言
整体网络结构
分解的yolov7.yaml
各组件结构
*
ELAN1 (backbone)
ELAN2 (head)
MPConv
SPPCSPC
RepConv（重参数卷积）
–
- 原理理解层面
- 代码实现层面
ImpConv（隐性知识学习）
–
- 训练时
- 推理时
References

前言

论文地址
 YOLOv7源码

下面对v0.1版本的整体网络结构及各个组件，结合源码和 train文件夹中的 yolov7.yaml配置文件进行解析。

整体网络结构

; 分解的yolov7.yaml


nc: 80
depth_multiple: 1.0
width_multiple: 1.0

anchors:
  - [12,16, 19,36, 40,28]
  - [36,75, 76,55, 72,146]
  - [142,110, 192,243, 459,401]

backbone:

  [[-1, 1, Conv, [32, 3, 1]],
   [-1, 1, Conv, [64, 3, 2]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [128, 3, 2]],

   [-1, 1, Conv, [64, 1, 1]],
   [-2, 1, Conv, [64, 1, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [[-1, -3, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1]],

   [-1, 1, MP, []],
   [-1, 1, Conv, [128, 1, 1]],
   [-3, 1, Conv, [128, 1, 1]],
   [-1, 1, Conv, [128, 3, 2]],
   [[-1, -3], 1, Concat, [1]],

   [-1, 1, Conv, [128, 1, 1]],
   [-2, 1, Conv, [128, 1, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [[-1, -3, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [512, 1, 1]],

   [-1, 1, MP, []],
   [-1, 1, Conv, [256, 1, 1]],
   [-3, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [256, 3, 2]],
   [[-1, -3], 1, Concat, [1]],

   [-1, 1, Conv, [256, 1, 1]],
   [-2, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [[-1, -3, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [1024, 1, 1]],

   [-1, 1, MP, []],
   [-1, 1, Conv, [512, 1, 1]],
   [-3, 1, Conv, [512, 1, 1]],
   [-1, 1, Conv, [512, 3, 2]],
   [[-1, -3], 1, Concat, [1]],

   [-1, 1, Conv, [256, 1, 1]],
   [-2, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [[-1, -3, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [1024, 1, 1]],
  ]

head:
  [[-1, 1, SPPCSPC, [512]],

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [37, 1, Conv, [256, 1, 1]],
   [[-1, -2], 1, Concat, [1]],

   [-1, 1, Conv, [256, 1, 1]],
   [-2, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [[-1, -2, -3, -4, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1]],

   [-1, 1, Conv, [128, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [24, 1, Conv, [128, 1, 1]],
   [[-1, -2], 1, Concat, [1]],

   [-1, 1, Conv, [128, 1, 1]],
   [-2, 1, Conv, [128, 1, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [[-1, -2, -3, -4, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [128, 1, 1]],

   [-1, 1, MP, []],
   [-1, 1, Conv, [128, 1, 1]],
   [-3, 1, Conv, [128, 1, 1]],
   [-1, 1, Conv, [128, 3, 2]],
   [[-1, -3, 63], 1, Concat, [1]],

   [-1, 1, Conv, [256, 1, 1]],
   [-2, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [[-1, -2, -3, -4, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1]],

   [-1, 1, MP, []],
   [-1, 1, Conv, [256, 1, 1]],
   [-3, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [256, 3, 2]],
   [[-1, -3, 51], 1, Concat, [1]],

   [-1, 1, Conv, [512, 1, 1]],
   [-2, 1, Conv, [512, 1, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [[-1, -2, -3, -4, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [512, 1, 1]],

   [75, 1, RepConv, [256, 3, 1]],
   [88, 1, RepConv, [512, 3, 1]],
   [101, 1, RepConv, [1024, 3, 1]],

   [[102,103,104], 1, IDetect, [nc, anchors]],
  ]

各组件结构

ELAN1 (backbone)

yolov7.yaml中对应部分：


   [-1, 1, Conv, [64, 1, 1]],
   [-2, 1, Conv, [64, 1, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [64, 3, 1]],
   [[-1, -3, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1]],

ELAN2 (head)

yolov7.yaml中对应部分：


   [-1, 1, Conv, [256, 1, 1]],
   [-2, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [[-1, -2, -3, -4, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1]],

MPConv

在 backnone中的对应部分
要注意相比于 MP函数之前， *通道数减少一半

   [-1, 1, Conv, [256, 1, 1]],

   [-1, 1, MP, []],
   [-1, 1, Conv, [128, 1, 1]],
   [-3, 1, Conv, [128, 1, 1]],
   [-1, 1, Conv, [128, 3, 2]],
   [[-1, -3], 1, Concat, [1]],

在 head中的对应部分
要注意相比于 MP函数之前， *通道数不变

   [-1, 1, Conv, [128, 1, 1]],

   [-1, 1, MP, []],
   [-1, 1, Conv, [128, 1, 1]],
   [-3, 1, Conv, [128, 1, 1]],
   [-1, 1, Conv, [128, 3, 2]],
   [[-1, -3, 63], 1, Concat, [1]],

SPPCSPC

类似于 yolov5中的 SPPF，不同的是，使用了5×5、9×9、13×13最大池化。

common.py中对应部分：

class SPPCSPC(nn.Module):

    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5, k=(5, 9, 13)):
        super(SPPCSPC, self).__init__()
        c_ = int(2 * c2 * e)
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(c_, c_, 3, 1)
        self.cv4 = Conv(c_, c_, 1, 1)
        self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])
        self.cv5 = Conv(4 * c_, c_, 1, 1)
        self.cv6 = Conv(c_, c_, 3, 1)
        self.cv7 = Conv(2 * c_, c2, 1, 1)

    def forward(self, x):
        x1 = self.cv4(self.cv3(self.cv1(x)))
        y1 = self.cv6(self.cv5(torch.cat([x1] + [m(x1) for m in self.m], 1)))
        y2 = self.cv2(x)
        return self.cv7(torch.cat((y1, y2), dim=1))

RepConv（重参数卷积）

; 原理理解层面

训练时：一个33卷积、一个11卷积和一个BN层（当输入输出通道相同时）相加得到输出
推理时：将以上三部分重参数化，合并为一个3*3的卷积输出

代码实现层面

训练时：不执行 Model类的 fuse函数
推理时：在 attempt_load函数加载训练好的模型时，会执行 Model类的 fuse函数，进而调用 fuse_repvgg_block函数， 实现将三个卷积重参数化，合并为一个卷积输出
common.py中对应部分：


class RepConv(nn.Module):
    '''重参数卷积
    训练时：
        deploy = False
        rbr_dense(3*3卷积) + rbr_1x1(1*1卷积) + rbr_identity(c2 == c1时) 三者相加
        rbr_reparam = None
    推理时：
        deploy = True
        rbr_reparam = Conv2d
        rbr_dense = None
        rbr_1x1 = None
        rbr_identity = None
    '''
    def __init__(self, c1, c2, k=3, s=1, p=None, g=1, act=True, deploy=False):
        super(RepConv, self).__init__()

        self.deploy = deploy
        self.groups = g
        self.in_channels = c1
        self.out_channels = c2

        assert k == 3
        assert autopad(k, p) == 1

        padding_11 = autopad(k, p) - k // 2

        self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())

        if deploy:
            self.rbr_reparam = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=True)

        else:

            self.rbr_identity = (nn.BatchNorm2d(num_features=c1) if c2 == c1 and s == 1 else None)

            self.rbr_dense = nn.Sequential(
                nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False),
                nn.BatchNorm2d(num_features=c2),
            )

            self.rbr_1x1 = nn.Sequential(
                nn.Conv2d(c1, c2, 1, s, padding_11, groups=g, bias=False),
                nn.BatchNorm2d(num_features=c2),
            )

    def forward(self, inputs):
        if hasattr(self, "rbr_reparam"):
            return self.act(self.rbr_reparam(inputs))

        if self.rbr_identity is None:
            id_out = 0
        else:
            id_out = self.rbr_identity(inputs)

        return self.act(self.rbr_dense(inputs) + self.rbr_1x1(inputs) + id_out)

    def fuse_conv_bn(self, conv, bn):

        std = (bn.running_var + bn.eps).sqrt()
        bias = bn.bias - bn.running_mean * bn.weight / std

        t = (bn.weight / std).reshape(-1, 1, 1, 1)
        weights = conv.weight * t

        bn = nn.Identity()
        conv = nn.Conv2d(in_channels=conv.in_channels,
                         out_channels=conv.out_channels,
                         kernel_size=conv.kernel_size,
                         stride=conv.stride,
                         padding=conv.padding,
                         dilation=conv.dilation,
                         groups=conv.groups,
                         bias=True,
                         padding_mode=conv.padding_mode)

        conv.weight = torch.nn.Parameter(weights)
        conv.bias = torch.nn.Parameter(bias)
        return conv

    def fuse_repvgg_block(self):
        if self.deploy:
            return
        print(f"RepConv.fuse_repvgg_block")

        self.rbr_dense = self.fuse_conv_bn(self.rbr_dense[0], self.rbr_dense[1])
        self.rbr_1x1 = self.fuse_conv_bn(self.rbr_1x1[0], self.rbr_1x1[1])
        rbr_1x1_bias = self.rbr_1x1.bias

        weight_1x1_expanded = torch.nn.functional.pad(self.rbr_1x1.weight, [1, 1, 1, 1])

        if (isinstance(self.rbr_identity, nn.BatchNorm2d) or isinstance(self.rbr_identity,
                                                                        nn.modules.batchnorm.SyncBatchNorm)):

            identity_conv_1x1 = nn.Conv2d(
                in_channels=self.in_channels,
                out_channels=self.out_channels,
                kernel_size=1,
                stride=1,
                padding=0,
                groups=self.groups,
                bias=False)
            identity_conv_1x1.weight.data = identity_conv_1x1.weight.data.to(self.rbr_1x1.weight.data.device)
            identity_conv_1x1.weight.data = identity_conv_1x1.weight.data.squeeze().squeeze()

            identity_conv_1x1.weight.data.fill_(0.0)
            identity_conv_1x1.weight.data.fill_diagonal_(1.0)
            identity_conv_1x1.weight.data = identity_conv_1x1.weight.data.unsqueeze(2).unsqueeze(3)

            identity_conv_1x1 = self.fuse_conv_bn(identity_conv_1x1, self.rbr_identity)
            bias_identity_expanded = identity_conv_1x1.bias
            weight_identity_expanded = torch.nn.functional.pad(identity_conv_1x1.weight, [1, 1, 1, 1])
        else:

            bias_identity_expanded = torch.nn.Parameter(torch.zeros_like(rbr_1x1_bias))
            weight_identity_expanded = torch.nn.Parameter(torch.zeros_like(weight_1x1_expanded))

        self.rbr_dense.weight = torch.nn.Parameter(
            self.rbr_dense.weight + weight_1x1_expanded + weight_identity_expanded)
        self.rbr_dense.bias = torch.nn.Parameter(self.rbr_dense.bias + rbr_1x1_bias + bias_identity_expanded)

        self.rbr_reparam = self.rbr_dense

        self.deploy = True

        if self.rbr_identity is not None:
            del self.rbr_identity
            self.rbr_identity = None

        if self.rbr_1x1 is not None:
            del self.rbr_1x1
            self.rbr_1x1 = None

        if self.rbr_dense is not None:
            del self.rbr_dense
            self.rbr_dense = None

ImpConv（隐性知识学习）

这一部分直接继承自YOLOR中的显隐性知识学习。一般情况下，将神经网络的浅层特征称为显性知识，深层特征称为隐性知识。 而YOLOR的作者（同时也是YOLOv7的作者）则直接把神经网络最终观察到的知识称为显性知识，那些观察不到、与观察无关的知识称为隐性知识。

在 model/common.py文件中，定义了两类隐性知识： ImplicitA和 ImplicitM，分别对输入相加和相乘：


class ImplicitA(nn.Module):
    def __init__(self, channel, mean=0., std=.02):
        super(ImplicitA, self).__init__()
        self.channel = channel
        self.mean = mean
        self.std = std

        self.implicit = nn.Parameter(torch.zeros(1, channel, 1, 1))
        nn.init.normal_(self.implicit, mean=self.mean, std=self.std)

    def forward(self, x):

        return self.implicit + x

class ImplicitM(nn.Module):
    def __init__(self, channel, mean=0., std=.02):
        super(ImplicitM, self).__init__()
        self.channel = channel
        self.mean = mean
        self.std = std

        self.implicit = nn.Parameter(torch.ones(1, channel, 1, 1))
        nn.init.normal_(self.implicit, mean=self.mean, std=self.std)

    def forward(self, x):

        return self.implicit * x

训练时

在模型训练阶段，先对输入进行 ImplicitA操作，在进行1*1卷积，最后进行 ImplicitM操作：

class IDetect(nn.Module):
    stride = None
    export = False
    end2end = False
    include_nms = False

    def __init__(self, nc=80, anchors=(), ch=()):
        super(IDetect, self).__init__()
        self.nc = nc
        self.no = nc + 5
        self.nl = len(anchors)
        self.na = len(anchors[0]) // 2
        self.grid = [torch.zeros(1)] * self.nl
        a = torch.tensor(anchors).float().view(self.nl, -1, 2)
        self.register_buffer('anchors', a)
        self.register_buffer('anchor_grid', a.clone().view(self.nl, 1, -1, 1, 1, 2))
        self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch)

        self.ia = nn.ModuleList(ImplicitA(x) for x in ch)
        self.im = nn.ModuleList(ImplicitM(self.no * self.na) for _ in ch)

    def forward(self, x):

        z = []
        self.training |= self.export
        for i in range(self.nl):

            x[i] = self.m[i](self.ia[i](x[i]))
            x[i] = self.im[i](x[i])

            bs, _, ny, nx = x[i].shape
            x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()

            if not self.training:
                if self.grid[i].shape[2:4] != x[i].shape[2:4]:
                    self.grid[i] = self._make_grid(nx, ny).to(x[i].device)

                y = x[i].sigmoid()
                y[..., 0:2] = (y[..., 0:2] * 2. - 0.5 + self.grid[i]) * self.stride[i]
                y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i]
                z.append(y.view(bs, -1, self.no))

        return x if self.training else (torch.cat(z, 1), x)

推理时

在模型推理阶段，将 ImplicitA-Conv-ImplicitM融合为一个1*1的 Conv操作：


def fuse(self):
    print("IDetect.fuse")

    for i in range(len(self.m)):
        c1, c2, _, _ = self.m[i].weight.shape
        c1_, c2_, _, _ = self.ia[i].implicit.shape
        self.m[i].bias += torch.matmul(self.m[i].weight.reshape(c1, c2),
                                       self.ia[i].implicit.reshape(c2_, c1_)).squeeze(1)

    for i in range(len(self.m)):
        c1, c2, _, _ = self.im[i].implicit.shape
        self.m[i].bias *= self.im[i].implicit.reshape(c2)
        self.m[i].weight *= self.im[i].implicit.transpose(0, 1)

References

[1] 深入浅出 Yolo 系列之 Yolov7 基础网络结构详解
[2] 【yolov7系列】网络框架细节拆解
[3] yolov7-GradCAM

Original: https://blog.csdn.net/weixin_43799388/article/details/126164288
Author: 嗜睡的篠龙
Title: 【YOLOv7_0.1】网络结构与源码解析

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/722050/

转载文章受原作者版权保护。转载请注明原作者出处！

人工智能

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

时间序列分析ARIMA及其Python实现

1 补充知识 1.1 相关函数自相关函数ACF(autocorrelation function) 自相关函数ACF描述的是时间序列观测值与其过去的观测值之间的线性相关性。计算公…

人工智能 2023年7月4日
00106
超分辨率基础

超分辨率综述Image Super-resolution 的深度学习方法微信二维码引擎OpenCV开源微信扫码背后的图像超分辨率技术技术解析 | 即构移动端超分辨率技术DIV2K数…

人工智能 2023年7月22日
0089
讯飞AIUI智能机器人5—–让器理解你（语音技术综合应用）

🍖🍖🍖🍖🍖🍖🍖🍖🍖 🍖🍖🍖🍖🍖🍖🍖🍖 🍖🍖🍖🍖🍖🍖🍖🍖 🍖🍖🍖🍖🍖🍖🍖🍖 🍖🍖🍖🍖🍖🍖🍖🍖 🍖🍖🍖🍖🍖🍖🍖🍖 🍖🍖🍖🍖🍖🍖🍖🍖 🍖🍖🍖🍖🍖🍖🍖🍖 🍖🍖🍖🍖🍖🍖🍖🍖 🍖🍖🍖🍖🍖🍖🍖🍖…

人工智能 2023年7月25日
0065
PyTorch学习率衰减策略：指数衰减（ExponentialLR）、固定步长衰减（StepLR）、多步长衰减（MultiStepLR）、余弦退火衰减（CosineAnnealingLR）

梯度下降算法需要我们指定一个学习率作为权重更新步幅的控制因子，常用的学习率有0.01、0.001以及0.0001等，学习率越大则权重更新。一般来说，我们希望在训练初期学习率大一些，…

人工智能 2023年7月21日
0055
图像分类/识别 VGG

VGG有很多个版本，也算是比较稳定和经典的model。它的特点也是连续conv多，计算量巨大（比前面几个都大很多）。（参数量：GoogleNet < AlexNet <…

人工智能 2023年7月2日
0068
Deformable DETR源码解读

文章目录一：网络创新点二：流程详解【part 1】deformable_detr模块 * 【part 2】deformable_transformer模块 – +…

人工智能 2023年6月16日
0090
R语言为dataframe添加新的数据列（add new columns）：使用R原生方法、data.table、dplyr等方案

[ 数据_运营作用&意义知错能改，善莫大焉 —错在哪里， _数据分析_告诉你运筹帷幄，决胜千里 —怎么做好”运筹”， _数据分析_告诉你以往…

人工智能 2023年6月15日
0062
一日一技：Python + Excel——飞速处理数据分析与处理

Python 可以为 Excel 做些什么？如果你经历过工作簿意外崩溃、计算出错，并且需要执行枯燥的手动操作，那么肯定想知道这个问题的答案。这本书是为工作表软件用户准备的一本全面又…

人工智能 2023年7月15日
0074
MapNet：Geometry-Aware Learning of Maps for Camera Localization相机定位的几何感知学习地图

摘要地图是基于图像的相机定位和视觉SLAM系统的关键组成部分。本文MapNet除了图像之外还利用廉价且无处不在的感官输入，如视觉里程计和GPS，并将它们融合在一起以进行相机定位。…

人工智能 2023年6月20日
0081
TensorRT 笔记-在 Conda 虚拟环境中安装

完成时间：2022 年 2 月 24 日最后修改：— 因为一些原因，要用到 TensorRT 对训练好的模型进行推理加速，官网的文档全英文看得累啊，想找找现成的中文文…

人工智能 2023年6月4日
0079
【项目实战】Python实现LightGBM分类模型(LGBMClassifier算法)项目实战

说明：这是一个机器学习实战项目（附带数据+代码+文档+代码讲解），如需数据+代码+文档+代码讲解可以直接到文章最后获取。 1.项目背景如今已是大数据时代，具备大数据思想至关重…

人工智能 2023年7月16日
0088
pytorch神经网络对Excel数据集进行处理2.0（读取，转为tensor格式，归一化），并且以鸢尾花（iris）数据集为例，实现BP神经网络

第一版本可以看1.0第二版本与1.0不一样的地方是使用了Dataset进行预处理数据，使用起来更加方便，同时使用了SummaryWriter保存准确率数据。其中SummaryWri…

人工智能 2023年7月21日
0093
cv2.add()和cv2.addWeighted()简要介绍

定义 cv2.add(X,Y) cv2.addWeighted(X,a,Y,y,b) 用法使用cv2.add(X,Y)是一种饱和操作，不同于numpy的加法（res = img1…

人工智能 2023年7月20日
0045
C++/OpenCV connectedComponentsWithStats函数异常解决方案（查找连通分量问题）

文章目录一、Mat.type()函数二、简单了解connectedComponentsWithStats函数三、问题代码 * 第四行代码异常报错如下：命令行窗口报错如下： …

人工智能 2023年7月20日
0076
来不及细说，毕业三天靠Python兼职赚了两千

前言考了英语四六级，没办法用英语交流3分钟。考了普通话证书，却没有一个HR关心这个。不喜欢自己的专业，没有好好学。万万没想到，大学四年，学到最有用的东西是驾驶证。这扎心的现实，…

人工智能 2023年7月3日
0073
halcon深度学习（分类）（1）

学习halocon自带的分类学习的例子： 创建网络和&#x65…

人工智能 2023年7月2日
0061

2024 年 5 月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31