深度学习 Day20——P9YOLOv5-Backbone模块实现

AI如何重构计算机视觉:从手工特征到端到端具身感知 计算机视觉(CV)正经历从‘手工设计特征’到‘数据驱动表征学习’的根本性转变。传统方法依赖边缘检测、HOG、SIFT等人工先验,泛化弱、调参难;而以卷积神经网络为代表的深度学习,通过端到端学习自动构建语义丰富的特征空间,显著提升小样本、复杂光照、遮挡等真实场景下的鲁棒性。自监督预训练进一步降低标注依赖,使模型在医疗、工业等数据稀缺领域快速落地;多模态对齐则突破单图局限,让文本成为视觉理解的通用接口。当前技术价值已不止于识别精度,更在于支撑实时推理优化与边缘部署,驱动CV从实验室走向产线、从静态分析迈向具身智 阅读详情


前言

本文将采用pytorch框架创建YOLOv5-C3模块实现天气识别。讲述实现代码与执行结果,并浅谈涉及知识点。
关键字: YOLOV5 Backbone

1 我的环境

  • 电脑系统:Windows 11
  • 语言环境:python 3.8.6
  • 编译器:pycharm2020.2.3
  • 深度学习环境:
    torch == 1.9.1+cu111
    torchvision == 0.10.1+cu111
  • 显卡:NVIDIA GeForce RTX 4070

2 代码实现与执行结果

2.1 前期准备

2.1.1 引入库


import torch
import torch.nn as nn
from torchvision import transforms, datasets
import time
from pathlib import Path
from PIL import Image
import torchsummary as summary
import torch.nn.functional as F

import copy
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100  # 分辨率
import warnings

warnings.filterwarnings('ignore')  # 忽略一些warning内容,无需打印

2.1.2 设置GPU(如果设备上支持GPU就使用GPU,否则使用CPU)

"""前期准备-设置GPU"""
# 如果设备上支持GPU就使用GPU,否则使用CPU
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print("Using {} device".format(device))

输出

Using cuda device

2.1.3 导入数据

'''前期工作-导入数据'''
data_dir = r"D:\DeepLearning\data\CoffeeBean"
data_dir = Path(data_dir)

data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[-1] for path in data_paths]
print(classeNames)

输出

['cloudy', 'rain', 'shine', 'sunrise']

2.1.4 可视化数据

'''前期工作-可视化数据'''
    subfolder = Path(data_dir)/"Angelina Jolie"
    image_files = list(p.resolve() for p in subfolder.glob('*') if p.suffix in [".jpg", ".png", ".jpeg"])
    plt.figure(figsize=(10, 6))
    for i in range(len(image_files[:12])):
        image_file = image_files[i]
        ax = plt.subplot(3, 4, i + 1)
        img = Image.open(str(image_file))
        plt.imshow(img)
        plt.axis("off")
    # 显示图片
    plt.tight_layout()
    plt.show()

在这里插入图片描述

2.1.4 图像数据变换

'''前期工作-图像数据变换'''
total_datadir = data_dir

# 关于transforms.Compose的更多介绍可以参考:https://blog.youkuaiyun.com/qq_38251616/article/details/124878863
train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    transforms.ToTensor(),  # 将PIL Image或numpy.ndarray转换为tensor,并归一化到[0,1]之间
    transforms.Normalize(  # 标准化处理-->转换为标准正太分布(高斯分布),使模型更容易收敛
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])
total_data = datasets.ImageFolder(total_datadir, transform=train_transforms)
print(total_data)
print(total_data.class_to_idx)

输出

Dataset ImageFolder
    Number of datapoints: 1125
    Root location: D:\DeepLearning\data\weather_photos
    StandardTransform
Transform: Compose(
               Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=None)
               ToTensor()
               Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
           )
{'cloudy': 0, 'rain': 1, 'shine': 2, 'sunrise': 3}

2.1.4 划分数据集

'''前期工作-划分数据集'''
train_size = int(0.8 * len(total_data))  # train_size表示训练集大小,通过将总体数据长度的80%转换为整数得到;
test_size = len(total_data) - train_size  # test_size表示测试集大小,是总体数据长度减去训练集大小。
# 使用torch.utils.data.random_split()方法进行数据集划分。该方法将总体数据total_data按照指定的大小比例([train_size, test_size])随机划分为训练集和测试集,
# 并将划分结果分别赋值给train_dataset和test_dataset两个变量。
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
print("train_dataset={}\ntest_dataset={}".format(train_dataset, test_dataset))
print("train_size={}\ntest_size={}".format(train_size, test_size))

输出

train_dataset=<torch.utils.data.dataset.Subset object at 0x0000020A3A209730>
test_dataset=<torch.utils.data.dataset.Subset object at 0x0000020A3A209BB0>
train_size=900
test_size=225

2.1.4 加载数据

'''前期工作-加载数据'''
batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset,
                                       batch_size=batch_size,
                                       shuffle=True,
                                       num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                      batch_size=batch_size,
                                      shuffle=True,
                                      num_workers=1)

2.1.4 查看数据

'''前期工作-查看数据'''
for X, y in test_dl:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

输出

Shape of X [N, C, H, W]:  torch.Size([32, 3, 224, 224])
Shape of y:  torch.Size([32]) torch.int64

2.2 搭建包含Backbone模块的模型

import torch.nn.functional as F

def autopad(k, p=None):  # kernel, padding
    # Pad to 'same'
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p

class Conv(nn.Module):
    # Standard convolution
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

class Bottleneck(nn.Module):
    # Standard bottleneck
    def __init__(self, c1, c2, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_, c2, 3, 1, g=g)
        self.add = shortcut and c1 == c2

    def forward(self, x):
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))

class C3(nn.Module):
    # CSP Bottleneck with 3 convolutions
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(2 * c_, c2, 1)  # act=FReLU(c2)
        self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))

    def forward(self, x):
        return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), dim=1))
    
class SPPF(nn.Module):
    # Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher
    def __init__(self, c1, c2, k=5):  # equivalent to SPP(k=(5, 9, 13))
        super().__init__()
        c_ = c1 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * 4, c2, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)

    def forward(self, x):
        x = self.cv1(x)
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')  # suppress torch 1.9.0 max_pool2d() warning
            y1 = self.m(x)
            y2 = self.m(y1)
            return self.cv2(torch.cat([x, y1, y2, self.m(y2)], 1))
"""
这个是YOLOv5, 6.0版本的主干网络,这里进行复现
(注:有部分删改,详细讲解将在后续进行展开)
"""
class YOLOv5_backbone(nn.Module):
    def __init__(self):
        super(YOLOv5_backbone, self).__init__()
        
        self.Conv_1 = Conv(3, 64, 3, 2, 2) 
        self.Conv_2 = Conv(64, 128, 3, 2) 
        self.C3_3   = C3(128,128)
        self.Conv_4 = Conv(128, 256, 3, 2) 
        self.C3_5   = C3(256,256)
        self.Conv_6 = Conv(256, 512, 3, 2) 
        self.C3_7   = C3(512,512)
        self.Conv_8 = Conv(512, 1024, 3, 2) 
        self.C3_9   = C3(1024, 1024)
        self.SPPF   = SPPF(1024, 1024, 5)
        
        # 全连接网络层,用于分类
        self.classifier = nn.Sequential(
            nn.Linear(in_features=65536, out_features=100),
            nn.ReLU(),
            nn.Linear(in_features=100, out_features=4)
        )
        
    def forward(self, x):
        x = self.Conv_1(x)
        x = self.Conv_2(x)
        x = self.C3_3(x)
        x = self.Conv_4(x)
        x = self.C3_5(x)
        x = self.Conv_6(x)
        x = self.C3_7(x)
        x = self.Conv_8(x)
        x = self.C3_9(x)
        x = self.SPPF(x)
        
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)

        return x

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))
    
model = YOLOv5_backbone().to(device)
print(summary.summary(model, (3, 224, 224)))#查看模型的参数量以及相关指标
    

输出

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 113, 113]           1,728
       BatchNorm2d-2         [-1, 64, 113, 113]             128
              SiLU-3         [-1, 64, 113, 113]               0
              Conv-4         [-1, 64, 113, 113]               0
            Conv2d-5          [-1, 128, 57, 57]          73,728
       BatchNorm2d-6          [-1, 128, 57, 57]             256
              SiLU-7          [-1, 128, 57, 57]               0
              Conv-8          [-1, 128, 57, 57]               0
            Conv2d-9           [-1, 64, 57, 57]           8,192
      BatchNorm2d-10           [-1, 64, 57, 57]             128
             SiLU-11           [-1, 64, 57, 57]               0
             Conv-12           [-1, 64, 57, 57]               0
           Conv2d-13           [-1, 64, 57, 57]           4,096
      BatchNorm2d-14           [-1, 64, 57, 57]             128
             SiLU-15           [-1, 64, 57, 57]               0
             Conv-16           [-1, 64, 57, 57]               0
           Conv2d-17           [-1, 64, 57, 57]          36,864
      BatchNorm2d-18           [-1, 64, 57, 57]             128
             SiLU-19           [-1, 64, 57, 57]               0
             Conv-20           [-1, 64, 57, 57]               0
       Bottleneck-21           [-1, 64, 57, 57]               0
           Conv2d-22           [-1, 64, 57, 57]           8,192
      BatchNorm2d-23           [-1, 64, 57, 57]             128
             SiLU-24           [-1, 64, 57, 57]               0
             Conv-25           [-1, 64, 57, 57]               0
           Conv2d-26          [-1, 128, 57, 57]          16,384
      BatchNorm2d-27          [-1, 128, 57, 57]             256
             SiLU-28          [-1, 128, 57, 57]               0
             Conv-29          [-1, 128, 57, 57]               0
               C3-30          [-1, 128, 57, 57]               0
           Conv2d-31          [-1, 256, 29, 29]         294,912
      BatchNorm2d-32          [-1, 256, 29, 29]             512
             SiLU-33          [-1, 256, 29, 29]               0
             Conv-34          [-1, 256, 29, 29]               0
           Conv2d-35          [-1, 128, 29, 29]          32,768
      BatchNorm2d-36          [-1, 128, 29, 29]             256
             SiLU-37          [-1, 128, 29, 29]               0
             Conv-38          [-1, 128, 29, 29]               0
           Conv2d-39          [-1, 128, 29, 29]          16,384
      BatchNorm2d-40          [-1, 128, 29, 29]             256
             SiLU-41          [-1, 128, 29, 29]               0
             Conv-42          [-1, 128, 29, 29]               0
           Conv2d-43          [-1, 128, 29, 29]         147,456
      BatchNorm2d-44          [-1, 128, 29, 29]             256
             SiLU-45          [-1, 128, 29, 29]               0
             Conv-46          [-1, 128, 29, 29]               0
       Bottleneck-47          [-1, 128, 29, 29]               0
           Conv2d-48          [-1, 128, 29, 29]          32,768
      BatchNorm2d-49          [-1, 128, 29, 29]             256
             SiLU-50          [-1, 128, 29, 29]               0
             Conv-51          [-1, 128, 29, 29]               0
           Conv2d-52          [-1, 256, 29, 29]          65,536
      BatchNorm2d-53          [-1, 256, 29, 29]             512
             SiLU-54          [-1, 256, 29, 29]               0
             Conv-55          [-1, 256, 29, 29]               0
               C3-56          [-1, 256, 29, 29]               0
           Conv2d-57          [-1, 512, 15, 15]       1,179,648
      BatchNorm2d-58          [-1, 512, 15, 15]           1,024
             SiLU-59          [-1, 512, 15, 15]               0
             Conv-60          [-1, 512, 15, 15]               0
           Conv2d-61          [-1, 256, 15, 15]         131,072
      BatchNorm2d-62          [-1, 256, 15, 15]             512
             SiLU-63          [-1, 256, 15, 15]               0
             Conv-64          [-1, 256, 15, 15]               0
           Conv2d-65          [-1, 256, 15, 15]          65,536
      BatchNorm2d-66          [-1, 256, 15, 15]             512
             SiLU-67          [-1, 256, 15, 15]               0
             Conv-68          [-1, 256, 15, 15]               0
           Conv2d-69          [-1, 256, 15, 15]         589,824
      BatchNorm2d-70          [-1, 256, 15, 15]             512
             SiLU-71          [-1, 256, 15, 15]               0
             Conv-72          [-1, 256, 15, 15]               0
       Bottleneck-73          [-1, 256, 15, 15]               0
           Conv2d-74          [-1, 256, 15, 15]         131,072
      BatchNorm2d-75          [-1, 256, 15, 15]             512
             SiLU-76          [-1, 256, 15, 15]               0
             Conv-77          [-1, 256, 15, 15]               0
           Conv2d-78          [-1, 512, 15, 15]         262,144
      BatchNorm2d-79          [-1, 512, 15, 15]           1,024
             SiLU-80          [-1, 512, 15, 15]               0
             Conv-81          [-1, 512, 15, 15]               0
               C3-82          [-1, 512, 15, 15]               0
           Conv2d-83           [-1, 1024, 8, 8]       4,718,592
      BatchNorm2d-84           [-1, 1024, 8, 8]           2,048
             SiLU-85           [-1, 1024, 8, 8]               0
             Conv-86           [-1, 1024, 8, 8]               0
           Conv2d-87            [-1, 512, 8, 8]         524,288
      BatchNorm2d-88            [-1, 512, 8, 8]           1,024
             SiLU-89            [-1, 512, 8, 8]               0
             Conv-90            [-1, 512, 8, 8]               0
           Conv2d-91            [-1, 512, 8, 8]         262,144
      BatchNorm2d-92            [-1, 512, 8, 8]           1,024
             SiLU-93            [-1, 512, 8, 8]               0
             Conv-94            [-1, 512, 8, 8]               0
           Conv2d-95            [-1, 512, 8, 8]       2,359,296
      BatchNorm2d-96            [-1, 512, 8, 8]           1,024
             SiLU-97            [-1, 512, 8, 8]               0
             Conv-98            [-1, 512, 8, 8]               0
       Bottleneck-99            [-1, 512, 8, 8]               0
          Conv2d-100            [-1, 512, 8, 8]         524,288
     BatchNorm2d-101            [-1, 512, 8, 8]           1,024
            SiLU-102            [-1, 512, 8, 8]               0
            Conv-103            [-1, 512, 8, 8]               0
          Conv2d-104           [-1, 1024, 8, 8]       1,048,576
     BatchNorm2d-105           [-1, 1024, 8, 8]           2,048
            SiLU-106           [-1, 1024, 8, 8]               0
            Conv-107           [-1, 1024, 8, 8]               0
              C3-108           [-1, 1024, 8, 8]               0
          Conv2d-109            [-1, 512, 8, 8]         524,288
     BatchNorm2d-110            [-1, 512, 8, 8]           1,024
            SiLU-111            [-1, 512, 8, 8]               0
            Conv-112            [-1, 512, 8, 8]               0
       MaxPool2d-113            [-1, 512, 8, 8]               0
       MaxPool2d-114            [-1, 512, 8, 8]               0
       MaxPool2d-115            [-1, 512, 8, 8]               0
          Conv2d-116           [-1, 1024, 8, 8]       2,097,152
     BatchNorm2d-117           [-1, 1024, 8, 8]           2,048
            SiLU-118           [-1, 1024, 8, 8]               0
            Conv-119           [-1, 1024, 8, 8]               0
            SPPF-120           [-1, 1024, 8, 8]               0
          Linear-121                  [-1, 100]       6,553,700
            ReLU-122                  [-1, 100]               0
          Linear-123                    [-1, 4]             404
================================================================
Total params: 21,729,592
Trainable params: 21,729,592
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 137.59
Params size (MB): 82.89
Estimated Total Size (MB): 221.06
----------------------------------------------------------------


2.3 训练模型

2.3.1 设置超参数

"""训练模型--设置超参数"""
loss_fn = nn.CrossEntropyLoss()  # 创建损失函数,计算实际输出和真实相差多少,交叉熵损失函数,事实上,它就是做图片分类任务时常用的损失函数
learn_rate = 1e-4  # 学习率
optimizer1 = torch.optim.SGD(model.parameters(), lr=learn_rate)# 作用是定义优化器,用来训练时候优化模型参数;其中,SGD表示随机梯度下降,用于控制实际输出y与真实y之间的相差有多大
optimizer2 = torch.optim.Adam(model.parameters(), lr=learn_rate)  
lr_opt = optimizer2
model_opt = optimizer2
# 调用官方动态学习率接口时使用2
lambda1 = lambda epoch : 0.92 ** (epoch // 4)
# optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(lr_opt, lr_lambda=lambda1) #选定调整方法

2.3.2 编写训练函数

"""训练模型--编写训练函数"""
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小,一共60000张图片
    num_batches = len(dataloader)  # 批次数目,1875(60000/32)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率

    for X, y in dataloader:  # 加载数据加载器,得到里面的 X(图片数据)和 y(真实标签)
        X, y = X.to(device), y.to(device) # 用于将数据存到显卡

        # 计算预测误差
        pred = model(X)  # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距,targets为真实值,计算二者差值即为损失

        # 反向传播
        optimizer.zero_grad()  # 清空过往梯度
        loss.backward()  # 反向传播,计算当前梯度
        optimizer.step()  # 根据梯度更新网络参数

        # 记录acc与loss
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc /= size
    train_loss /= num_batches

    return train_acc, train_loss

2.3.3 编写测试函数

"""训练模型--编写测试函数"""
# 测试函数和训练函数大致相同,但是由于不进行梯度下降对网络权重进行更新,所以不需要传入优化器
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)  # 测试集的大小,一共10000张图片
    num_batches = len(dataloader)  # 批次数目,313(10000/32=312.5,向上取整)
    test_loss, test_acc = 0, 0

    # 当不进行训练时,停止梯度更新,节省计算内存消耗
    with torch.no_grad(): # 测试时模型参数不用更新,所以 no_grad,整个模型参数正向推就ok,不反向更新参数
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()#统计预测正确的个数

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss

2.3.4 正式训练

"""训练模型--正式训练"""
epochs = 60
train_loss = []
train_acc = []
test_loss = []
test_acc = []
best_test_acc=0

for epoch in range(epochs):
    milliseconds_t1 = int(time.time() * 1000)

    # 更新学习率(使用自定义学习率时使用)
    # adjust_learning_rate(lr_opt, epoch, learn_rate)

    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, model_opt)
    scheduler.step() # 更新学习率(调用官方动态学习率接口时使用)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    # 获取当前的学习率
    lr = lr_opt.state_dict()['param_groups'][0]['lr']

    milliseconds_t2 = int(time.time() * 1000)
    template = ('Epoch:{:2d}, duration:{}ms, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%,Test_loss:{:.3f}, Lr:{:.2E}')
    if best_test_acc < epoch_test_acc:
        best_test_acc = epoch_test_acc
        #备份最好的模型
        best_model = copy.deepcopy(model)
        template = (
            'Epoch:{:2d}, duration:{}ms, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%,Test_loss:{:.3f}, Lr:{:.2E},Update the best model')
    print(
        template.format(epoch + 1, milliseconds_t2-milliseconds_t1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss, lr))
# 保存最佳模型到文件中
PATH = './best_model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)
print('Done')

输出最高精度为Test_acc:95.6%

Epoch: 1, duration:6835ms, Train_acc:64.6%, Train_loss:0.868, Test_acc:16.0%,Test_loss:3.079, Lr:1.00E-04,Update the best model
Epoch: 2, duration:5852ms, Train_acc:65.2%, Train_loss:0.785, Test_acc:77.8%,Test_loss:0.597, Lr:1.00E-04,Update the best model
Epoch: 3, duration:5958ms, Train_acc:73.3%, Train_loss:0.595, Test_acc:76.4%,Test_loss:0.518, Lr:1.00E-04
...
Epoch:58, duration:6514ms, Train_acc:98.2%, Train_loss:0.052, Test_acc:92.9%,Test_loss:0.272, Lr:1.00E-04
Epoch:59, duration:6305ms, Train_acc:99.1%, Train_loss:0.042, Test_acc:92.4%,Test_loss:0.219, Lr:1.00E-04
Epoch:60, duration:6294ms, Train_acc:96.9%, Train_loss:0.143, Test_acc:92.0%,Test_loss:0.199, Lr:1.00E-04

2.4 结果可视化

"""训练模型--结果可视化"""
epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

在这里插入图片描述

2.4 指定图片进行预测

def predict_one_image(image_path, model, transform, classes):
    test_img = Image.open(image_path).convert('RGB')
    plt.imshow(test_img)  # 展示预测的图片
    plt.show()

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)

    model.eval()
    output = model(img)

    _, pred = torch.max(output, 1)
    pred_class = classes[pred]
    print(f'预测结果是:{pred_class}')
 
# 将参数加载到model当中
model.load_state_dict(torch.load(PATH, map_location=device))

"""指定图片进行预测"""
classes = list(total_data.class_to_idx)
# 预测训练集中的某张照片
predict_one_image(image_path=str(Path(data_dir)/"Dark/dark (1).png"),
                  model=model,
                  transform=train_transforms,
                  classes=classes)

在这里插入图片描述

输出

预测结果是:cloudy

2.6 模型评估

"""模型评估"""
best_model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, best_model, loss_fn)
# 查看是否与我们记录的最高准确率一致
print(epoch_test_acc, epoch_test_loss)


输出


0.9555555555555556 0.15073023055447266

3 知识点详解

3.1 Yolov5四种网络模型

Yolov5官方代码中,给出的目标检测网络中一共有4个版本,分别是Yolov5s、Yolov5m、Yolov5l、Yolov5x四个模型。

学习一个新的算法,最好在脑海中对算法网络的整体架构有一个清晰的理解。

但比较尴尬的是,Yolov5代码中给出的网络文件是yaml格式,和原本Yolov3、Yolov4中的cfg不同。

因此无法用netron工具直接可视化的查看网络结构,造成有的同学不知道如何去学习这样的网络。

比如下载了Yolov5的四个pt格式的权重模型:
在这里插入图片描述

在《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中讲到,可以使用netron工具打开网络模型。

但因为netron对pt格式的文件兼容性并不好,直接使用netron工具打开,会发现,根本无法显示全部网络。

因此可以采用pt->onnx->netron的折中方式,先使用Yolov5代码中models/export.py脚本将pt文件转换为onnx格式,再用netron工具打开,这样就可以看全网络的整体架构了。
在这里插入图片描述

如果有同学对netron工具还不是很熟悉,这里还是放上安装netron工具的详解,如果需要安装,可以移步另一篇文章:《网络可视化工具netron详细安装流程》

如需下载Yolov5整体的4个网络pt文件及onnx文件,也可点击链接查看下载,便于直观的学习。

3.1.1 Yolov5网络结构图

安装好netron工具,就可以可视化的打开Yolov5的网络结构。

这里也和之前讲解Yolov3&Yolov4同样的方式,绘制了Yolov5s整体的网络结构图。配合netron的可视化网络结构查看,脑海中的架构会更加清晰。
在这里插入图片描述

本文也会以Yolov5s的网络结构为主线,讲解与其他三个模型(Yolov5m、Yolov5l、Yolov5x)的不同点,让大家对于Yolov5有一个深入浅出的了解。

3.1.2 网络结构可视化

将四种模型pt文件的转换成对应的onnx文件后,即可使用netron工具查看。
但是,有些同学可能不方便,使用脚本转换查看。
因此,也上传了每个网络结构图的图片,也可以直接点击查看。
虽然没有netron工具更直观,但是也可以学习了解。

3.1.2.1 Yolov5s网络结构

Yolov5s网络是Yolov5系列中深度最小,特征图的宽度最小的网络。后面的3种都是在此基础上不断加深,不断加宽。

上图绘制出的网络结构图也是Yolov5s的结构,大家也可直接点击查看,Yolov5s的网络结构可视化的图片。

3.1.2.2 Yolov5m网络结构

此处也放上netron打开的Yolov5m网络结构可视图,点击即可查看,后面第二版块会详细说明不同模型的不同点。

3.1.2.3 Yolov5l网络结构

此处也放上netronx打开的Yolov5l网络结构可视图,点击即可查看。

3.1.2.4 Yolov5x网络结构

此处也放上netronx打开的Yolov5x网络结构可视图,点击即可查看。

3.2 核心基础内容

3.2.1 Yolov3&Yolov4网络结构图

3.2.1.1 Yolov3网络结构图

Yolov3的网络结构是比较经典的one-stage结构,分为输入端、Backbone、Neck和Prediction四个部分。

在之前的《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中讲了很多,这里不多说,还是放上绘制的Yolov3的网络结构图。

在这里插入图片描述

3.2.1.2 Yolov4网络结构图

Yolov4在Yolov3的基础上进行了很多的创新。
比如输入端采用mosaic数据增强,
Backbone上采用了CSPDarknet53、Mish激活函数、Dropblock等方式,
Neck中采用了SPP、FPN+PAN的结构,
输出端则采用CIOU_Loss、DIOU_nms操作。

因此Yolov4对Yolov3的各个部分都进行了很多的整合创新,关于Yolov4详细的讲解还是可以参照之前写的《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》,写的比较详细。
在这里插入图片描述

3.2.2 Yolov5核心基础内容

Yolov5的结构和Yolov4很相似,但也有一些不同,还是按照从整体到细节的方式,对每个板块进行讲解。

在这里插入图片描述

上图即Yolov5的网络结构图,可以看出,还是分为输入端、Backbone、Neck、Prediction四个部分。

大家可能对Yolov3比较熟悉,因此列举它和Yolov3的一些主要的不同点,并和Yolov4进行比较。

(1)输入端:Mosaic数据增强、自适应锚框计算、自适应图片缩放
(2)Backbone:Focus结构,CSP结构
(3)Neck:FPN+PAN结构
(4)Prediction:GIOU_Loss

下面丢上Yolov5作者的算法性能测试图:
在这里插入图片描述

Yolov5作者也是在COCO数据集上进行的测试,在之前的文章讲过,COCO数据集的小目标占比,因此最终的四种网络结构,性能上来说各有千秋。

Yolov5s网络最小,速度最少,AP精度也最低。但如果检测的以大目标为主,追求速度,倒也是个不错的选择。

其他的三种网络,在此基础上,不断加深加宽网络,AP精度也不断提升,但速度的消耗也在不断增加。

3.2.2.1 输入端

(1)Mosaic数据增强

Yolov5的输入端采用了和Yolov4一样的Mosaic数据增强的方式。

Mosaic数据增强提出的作者也是来自Yolov5团队的成员,不过,随机缩放、随机裁剪、随机排布的方式进行拼接,对于小目标的检测效果还是很不错的。
在这里插入图片描述

Mosaic数据增强的内容在之前《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》文章中写的很详细,详情可以查看之前的内容。

(2) 自适应锚框计算

在Yolo算法中,针对不同的数据集,都会有初始设定长宽的锚框。

在网络训练中,网络在初始锚框的基础上输出预测框,进而和真实框groundtruth进行比对,计算两者差距,再反向更新,迭代网络参数。

因此初始锚框也是比较重要的一部分,比如Yolov5在Coco数据集上初始设定的锚框:
在这里插入图片描述

在Yolov3、Yolov4中,训练不同的数据集时,计算初始锚框的值是通过单独的程序运行的。

但Yolov5中将此功能嵌入到代码中,每次训练时,自适应的计算不同训练集中的最佳锚框值。

当然,如果觉得计算的锚框效果不是很好,也可以在代码中将自动计算锚框功能关闭。
在这里插入图片描述

控制的代码即train.py中上面一行代码,设置成False,每次训练时,不会自动计算。

(3)自适应图片缩放

在常用的目标检测算法中,不同的图片长宽都不相同,因此常用的方式是将原始图片统一缩放到一个标准尺寸,再送入检测网络中。

比如Yolo算法中常用416416,608608等尺寸,比如对下面800*600的图像进行缩放。
在这里插入图片描述

但Yolov5代码中对此进行了改进,也是Yolov5推理速度能够很快的一个不错的trick。

作者认为,在项目实际使用时,很多图片的长宽比不同,因此缩放填充后,两端的黑边大小都不同,而如果填充的比较多,则存在信息冗余,影响推理速度。

因此在Yolov5的代码中datasets.py的letterbox函数中进行了修改,对原始图像自适应的添加最少的黑边。
在这里插入图片描述

图像高度上两端的黑边变少了,在推理时,计算量也会减少,即目标检测速度会得到提升。

这种方式在之前github上Yolov3中也进行了讨论:https://github.com/ultralytics/yolov3/issues/232

在讨论中,通过这种简单的改进,推理速度得到了37%的提升,可以说效果很明显。

但是有的同学可能会有大大的问号??如何进行计算的呢?按照Yolov5中的思路详细的讲解一下,在datasets.py的letterbox函数中也有详细的代码。

第一步:计算缩放比例
在这里插入图片描述

原始缩放尺寸是416*416,都除以原始图像的尺寸后,可以得到0.52,和0.69两个缩放系数,选择小的缩放系数。

第二步:计算缩放后的尺寸
在这里插入图片描述

原始图片的长宽都乘以最小的缩放系数0.52,宽变成了416,而高变成了312。

第三步:计算黑边填充数值

在这里插入图片描述

将416-312=104,得到原本需要填充的高度。再采用numpy中np.mod取余数的方式,得到8个像素,再除以2,即得到图片高度两端需要填充的数值。

此外,需要注意的是:

a.这里填充的是黑色,即(0,0,0),而Yolov5中填充的是灰色,即(114,114,114),都是一样的效果。

b.训练时没有采用缩减黑边的方式,还是采用传统填充的方式,即缩放到416*416大小。只是在测试,使用模型推理时,才采用缩减黑边的方式,提高目标检测,推理的速度。

c.为什么np.mod函数的后面用32?因为Yolov5的网络经过5次下采样,而2的5次方,等于32。所以至少要去掉32的倍数,再进行取余。

2.2.2 Backbone
(1)Focus结构

在这里插入图片描述

Focus结构,在Yolov3&Yolov4中并没有这个结构,其中比较关键是切片操作。

比如右图的切片示意图,443的图像切片后变成2212的特征图。

以Yolov5s的结构为例,原始6086083的图像输入Focus结构,采用切片操作,先变成30430412的特征图,再经过一次32个卷积核的卷积操作,最终变成30430432的特征图。

需要注意的是:Yolov5s的Focus结构最后使用了32个卷积核,而其他三种结构,使用的数量有所增加,先注意下,后面会讲解到四种结构的不同点。

(2)CSP结构

Yolov4网络结构中,借鉴了CSPNet的设计思路,在主干网络中设计了CSP结构。
在这里插入图片描述

Yolov5与Yolov4不同点在于,Yolov4中只有主干网络使用了CSP结构。

而Yolov5中设计了两种CSP结构,以Yolov5s网络为例,CSP1_X结构应用于Backbone主干网络,另一种CSP2_X结构则应用于Neck中。
在这里插入图片描述

这里关于CSPNet的内容,也可以查看之前的《深入浅出Yolo系列之Yolov3&Yolov4核心基础完整讲解》。

2.2.3 Neck
Yolov5现在的Neck和Yolov4中一样,都采用FPN+PAN的结构,但在Yolov5刚出来时,只使用了FPN结构,后面才增加了PAN结构,此外网络中其他部分也进行了调整。

因此,在Yolov5刚提出时,画的很多结构图,又都重新进行了调整。
在这里插入图片描述

这里关于FPN+PAN的结构,在《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中,讲的很多,大家应该都有理解。

但如上面CSPNet结构中讲到,Yolov5和Yolov4的不同点在于,

Yolov4的Neck结构中,采用的都是普通的卷积操作。而Yolov5的Neck结构中,采用借鉴CSPnet设计的CSP2结构,加强网络特征融合的能力。
在这里插入图片描述

2.2.4 输出端
(1)Bounding box损失函数

在《深入浅出Yolo系列之Yolov3&Yolov4核心基础知识完整讲解》中,详细的讲解了IOU_Loss,以及进化版的GIOU_Loss,DIOU_Loss,以及CIOU_Loss。

Yolov5中采用其中的CIOU_Loss做Bounding box的损失函数。
在这里插入图片描述

Yolov4中也采用CIOU_Loss作为目标Bounding box的损失。
在这里插入图片描述

(2)nms非极大值抑制

在目标检测的后处理过程中,针对很多目标框的筛选,通常需要nms操作。

因为CIOU_Loss中包含影响因子v,涉及groudtruth的信息,而测试推理时,是没有groundtruth的。

所以Yolov4在DIOU_Loss的基础上采用DIOU_nms的方式,而Yolov5中采用加权nms的方式。

可以看出,采用DIOU_nms,下方中间箭头的黄色部分,原本被遮挡的摩托车也可以检出。
在这里插入图片描述

在项目中,也采用了DIOU_nms的方式,在同样的参数情况下,将nms中IOU修改成DIOU_nms。对于一些遮挡重叠的目标,确实会有一些改进。

比如下面黄色箭头部分,原本两个人重叠的部分,在参数和普通的IOU_nms一致的情况下,修改成DIOU_nms,可以将两个目标检出。

虽然大多数状态下效果差不多,但在不增加计算成本的情况下,有稍微的改进也是好的。
在这里插入图片描述

2.3 Yolov5四种网络结构的不同点
Yolov5代码中的四种网络,和之前的Yolov3,Yolov4中的cfg文件不同,都是以yaml的形式来呈现。

而且四个文件的内容基本上都是一样的,只有最上方的depth_multiple和width_multiple两个参数不同,很多同学看的一脸懵逼,不知道只通过两个参数是如何控制四种结构的?

2.3.1 四种结构的参数
先取出Yolov5代码中,每个网络结构的两个参数:

(1)Yolov5s.yaml
在这里插入图片描述

(2)Yolov5m.yaml
在这里插入图片描述

(3)Yolov5l.yaml
在这里插入图片描述

(4)Yolov5x.yaml
在这里插入图片描述

四种结构就是通过上面的两个参数,来进行控制网络的深度和宽度。其中depth_multiple控制网络的深度,width_multiple控制网络的宽度。

2.3.2 Yolov5网络结构
四种结构的yaml文件中,下方的网络架构代码都是一样的。

为了便于讲解,将其中的Backbone部分提取出来,讲解如何控制网络的宽度和深度,yaml文件中的Head部分也是同样的原理。
在这里插入图片描述

在对网络结构进行解析时,yolo.py中下方的这一行代码将四种结构的depth_multiple,width_multiple提取出,赋值给gd,gw。后面主要对这gd,gw这两个参数进行讲解。
在这里插入图片描述

下面再细致的剖析下,看是如何控制每种结构,深度和宽度的。

2.3.3 Yolov5四种网络的深度

(1)不同网络的深度
在这里插入图片描述

在上图中,画了两种CSP结构,CSP1和CSP2,其中CSP1结构主要应用于Backbone中,CSP2结构主要应用于Neck中。

需要注意的是,四种网络结构中每个CSP结构的深度都是不同的。

a.以yolov5s为例,第一个CSP1中,使用了1个残差组件,因此是CSP1_1。而在Yolov5m中,则增加了网络的深度,在第一个CSP1中,使用了2个残差组件,因此是CSP1_2。

而Yolov5l中,同样的位置,则使用了3个残差组件,Yolov5x中,使用了4个残差组件。

其余的第二个CSP1和第三个CSP1也是同样的原理。

b.在第二种CSP2结构中也是同样的方式,以第一个CSP2结构为例,Yolov5s组件中使用了2×X=2×1=2个卷积,因为X=1,所以使用了1组卷积,因此是CSP2_1。

而Yolov5m中使用了2组,Yolov5l中使用了3组,Yolov5x中使用了4组。

其他的四个CSP2结构,也是同理。

Yolov5中,网络的不断加深,也在不断增加网络特征提取和特征融合的能力。

(2)控制深度的代码

控制四种网络结构的核心代码是yolo.py中下面的代码,存在两个变量,n和gd。

我们再将n和gd带入计算,看每种网络的变化结果。
在这里插入图片描述

(3)验证控制深度的有效性

我们选择最小的yolov5s.yaml和中间的yolov5l.yaml两个网络结构,将gd(depth_multiple)系数带入,看是否正确。
在这里插入图片描述

a. yolov5s.yaml

其中depth_multiple=0.33,即gd=0.33,而n则由上面红色框中的信息获得。

以上面网络框图中的第一个CSP1为例,即上面的第一个红色框。n等于第二个数值3。

而gd=0.33,带入(2)中的计算代码,结果n=1。因此第一个CSP1结构内只有1个残差组件,即CSP1_1。

第二个CSP1结构中,n等于第二个数值9,而gd=0.33,带入(2)中计算,结果n=3,因此第二个CSP1结构中有3个残差组件,即CSP1_3。

第三个CSP1结构也是同理,这里不多说。

b. yolov5l.xml

其中depth_multiple=1,即gd=1

和上面的计算方式相同,第一个CSP1结构中,n=3,带入代码中,结果n=3,因此为CSP1_3。

下面第二个CSP1和第三个CSP1结构都是同样的原理。

2.3.4 Yolov5四种网络的宽度

(1)不同网络的宽度:
在这里插入图片描述

如上图表格中所示,四种yolov5结构在不同阶段的卷积核的数量都是不一样的,因此也直接影响卷积后特征图的第三维度,即厚度,这里表示为网络的宽度。

a.以Yolov5s结构为例,第一个Focus结构中,最后卷积操作时,卷积核的数量是32个,因此经过Focus结构,特征图的大小变成30430432。

而yolov5m的Focus结构中的卷积操作使用了48个卷积核,因此Focus结构后的特征图变成30430448。yolov5l,yolov5x也是同样的原理。

b. 第二个卷积操作时,yolov5s使用了64个卷积核,因此得到的特征图是15215264。而yolov5m使用96个特征图,因此得到的特征图是15215296。yolov5l,yolov5x也是同理。

c. 后面三个卷积下采样操作也是同样的原理,这样不过多讲解。

四种不同结构的卷积核的数量不同,这也直接影响网络中,比如CSP1,CSP2等结构,以及各个普通卷积,卷积操作时的卷积核数量也同步在调整,影响整体网络的计算量。

大家最好可以将结构图和前面第一部分四个网络的特征图链接,对应查看,思路会更加清晰。

当然卷积核的数量越多,特征图的厚度,即宽度越宽,网络提取特征的学习能力也越强。

(2)控制宽度的代码

在yolov5的代码中,控制宽度的核心代码是yolo.py文件里面的这一行:
在这里插入图片描述

它所调用的子函数make_divisible的功能是:
在这里插入图片描述

(3)验证控制宽度的有效性

我们还是选择最小的yolov5s和中间的yolov5l两个网络结构,将width_multiple系数带入,看是否正确。
在这里插入图片描述

a. yolov5s.yaml

其中width_multiple=0.5,即gw=0.5。

在这里插入图片描述

以第一个卷积下采样为例,即Focus结构中下面的卷积操作。

按照上面Backbone的信息,我们知道Focus中,标准的c2=64,而gw=0.5,代入(2)中的计算公式,最后的结果=32。即Yolov5s的Focus结构中,卷积下采样操作的卷积核数量为32个。

再计算后面的第二个卷积下采样操作,标准c2的值=128,gw=0.5,代入(2)中公式,最后的结果=64,也是正确的。

b. yolov5l.yaml

其中width_multiple=1,即gw=1,而标准的c2=64,代入上面(2)的计算公式中,可以得到Yolov5l的Focus结构中,卷积下采样操作的卷积核的数量为64个,而第二个卷积下采样的卷积核数量是128个。

另外的三个卷积下采样操作,以及yolov5m,yolov5x结构也是同样的计算方式,这里不过多解释。

参考链接:
深入浅出Yolo系列之Yolov5核心基础知识完整讲解

总结

通过本文的学习,对YOLOv5网络结构有了一个初步的了解。

深度学习模块缝合教程:从理论到实践 模块缝合是深度学习研究中的一个重要环节。无论是创造新模块还是复用现有模块,都需要理论与实践相结合。创新需要深厚的技术积累和对前沿领域的关注。缝合需要灵活的思维方式和扎实的实验基础。复用则需要对不同领域的需求有深刻理解。 阅读详情

相关推荐

LightGBM学习笔记

LightGB学习笔记1. lightgbm概述1.1 lightgbm介绍1.2 lightgbm和xgboost对比2 .直方图算法及改进2.1 直方图算法2.2 直方图算法改进2.2.1 GOSS算法3.树的生长策略4.系统设计5. 实战 lightgbm是基于boosting的学习框架,使用的是基于决策树的学习算法,具有更快的训练速度、更低的内存使用、更高的正确率、并且能够支持并行化学习,可以用来处理大规模数据,本文主要是针对学习视频https://www.bilibili.com/video/BV

一一xi的博客 3308

深度学习中模块设计汇总(一)

2.1离散小波逆变换 Inverse discrete wavelet transform (IDWT)全局上下文 res-dense 模块包含一个残差密集块 (RDB) 和一个全局上下文块 (GCB)DWT 的本质是将输入特征图分解为高频和低频分量,离散小波变换(DWT)上采样和下采样。1.全局上下文 res-dense 模块。1.2 全局上下文块 (GCB)1.1 残差密集块 (RDB)2.离散小波变换(DWT)............

learning5201的博客 3260

Rocky Linux 9 离线环境Docker部署实战:从依赖打包到服务启动

本文提供了一份详尽的Rocky Linux 9离线环境Docker部署实战指南。针对无法访问外网的生产或内网服务器,文章详细讲解了如何在联网跳板机上下载Docker二进制包及所有系统依赖RPM包,并完成打包。随后,手把手指导在离线服务器上进行依赖安装、二进制文件部署、systemd服务配置、SELinux与防火墙调优,最终实现Docker服务的成功启动与验证。

weixin_28363123的博客 144

深度学习 常见模块

本片博客介绍深度学习中常用的几个库:cuDNN, timm, amp, yacs, argparse

qq_46277596的博客 2903

AI智算-K8s如何利用GPFS分布式并行文件存储加速训练or推理

GPFS(General Parallel File System,通用并行文件系统)是由 IBM 开发的高性能分布式文件系统,最初设计于 1990 年代,用于满足高性能计算(HPC)环境对大规模数据存储和访问的需求。GPFS 现已广泛应用于企业级存储、云计算、大数据分析、人工智能和媒体处理等领域。它以其高性能、可扩展性和可靠性著称,能够支持从小型集群到超大规模系统的各种部署场景。

Kason_iWiki 1132

通信算法之289:数据链/自组网通信设备--MIMO(2T2R)-SFBC-单载波频域均衡(SCFDE)系统系列--实际工程应用算法代码--2.SFBC-SCFDE原理讲解

OFDM传输系统,频谱利用率高,能够有效对抗多径衰落,并且可以通过设置不同的子载波数目来实现非对称数据传输,峰均比比高、易受频偏影响。SCFDE系统峰均比低、且对频偏不敏感。传输速率的增大会使得频率选择性衰落加剧,符号间干扰更加严重。

leegang12的专栏 293

深度学习模块汇总(一)

深度学习模块汇总

weixin_63087177的博客 2747

《电磁兼容设计》专栏说明

本专栏自2024年1月起开始更新,仅设此一个电磁兼容相关知识专栏,并将一直持续更新下去,无期限

linkking27的博客 794

深度学习模块创作(缝合)教程|适合1-360月小宝宝食用,干货满满

第二种层次也是论文用的最多的层次,就是将已经有的模块融入到现有的其他模块中,组成新的模块,像是增加、替换模块或结构。结构上,InceptionDWConv2d首先对输入的张量x切分,分别执行卷积核大小3×3、1×11、11×1的三组深度可分离卷积和一组恒等映射,既能感知多尺度特征,同时只对一部分x进行操作,减小了计算量,主要代码也很短,仅有简单的四行发顶会。这里比较典型的模块结构(网络)就是Resnet残差块,可以说没有何凯明的Resnet,深度学习难以发展到现在的高度,这也是深度学习的基石性研究。

深度学习炼丹师,偶尔分享炼丹技术! 3402

15-YOLOV8OBB损失函数详解

在Ultralytics YOLO 模型中,OBB 由YOLO OBB 格式中的四个角点表示。这样可以更准确地检测到物体,因为边界框可以旋转以更好地适应物体。其坐标在 0 和 1 之间归一化:YOLO 在内部处理损失和输出是xywhr 格式,xy表示边界框的中心点、whr表示宽度、高度和旋转角度。

zqb_123的博客 798

BAT007:批量为当前目录下的文件夹添加前缀或后缀

摘要:编写批处理程序,实现批量为当前目录下的文件夹添加前缀或后缀。

qq_31762031的博客 4054

深度学习模块汇总(二)

地址:https://openaccess.thecvf.com/content/WACV2021/papers/Misra_Rotate_to_Attend_Convolutional_Triplet_Attention_Module_WACV_2021_paper.pdf。地址:https://arxiv.org/abs/2012.11879https://arxiv.org/abs/2107.12292)SA模块有效地融合了两种类型的注意力机制,不仅保持了模型的轻量化,还显著提高了模型的性能。

weixin_63087177的博客 1519

【智能车Code review】——小S与中S道路判断

基本思想: 找到中线的左拐点和右拐点,并且计算出两点之间的空间距离。通过限制空间距离,分为中S和小S。 注意这种情况:当20行以下的中线斜率比较陡,此时可以通过人为限制设定,将第0行的中线设置为拐点。 if (flag_centre_right_point == 0 && flag_centre_left_point == 1 && parameterB >= 0.5 && centre_left_point[0] >= 33) { .

hanhan的博客 6107

深度学习 Day 31——YOLOv5-Backbone模块实现

365天深度学习训练营 [第二十二周]——本期博客我们将利用YOLOv5算法中的Backbone模块搭建网络,了解学习一下Backbone的结构,方便后续我们的YOLOv5算法的学习。

北天的博客 1413

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

【Reading Notes】(6)Favorite Articles from 2023

Feature-Based Knowledge,一般而言,在基于特征的知识迁移中,研究的对象包括了:如何需选择知识类型?对于台积电的客户来说,这个数字是难以接受的,因为客户需要为整个晶圆买单,包括其中有缺陷的芯片。最后大家采取了一个折中方案,4号线经过北大的789米轨道段,将采用世界上最先进的轨道减振技术,也就是在钢轨下铺设钢弹簧浮置板。毕竟,有苹果这样的金主愿意成为台积电新制造工艺的第一个客户,能分担台积电先进制程节点的研发费用和专用工厂的建设费用。(2023年01月01日)(2023年01月04日)

bryant_meng 1717

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

【YOLOv5】Backbone、Neck、Head各模块详解

详解Yolov5原理及backbone、neck、head三个模块的作用及结构。

qq_44878985的博客 10万+

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

常见的深度学习基础模块总结

然后输入embedding乘上Q其实还是可以理解成原Token表示(就加了个权重),乘上K后,就变成了token之间的正方形相关矩阵(假设输入“我爱你”,编码为123,那第一行相关矩阵是【1 * 1,1 * 2,1 * 3】)。再乘以一个V,V的每一列可以看成【1,2,3】,那么【QK】的第一行乘以V每一列,每个数结果都是【111+122+133】(乘号省略),这些数形成的列表,就是【QK】*V的第一行。在这个列表中,融合了1的自身情况与其他2,3token的相关情况,2,3的位置情况。

skyeah_的博客 1438

深度学习经验

缝合模块:可以自已写一个test检验这个模块(即插即用)有效性,利用torch.randn(N,C,H,W),其中输入即为我们想要插入我们想缝合模块前的模块输入利用print打印出其shape,然后把该模块(即插即用)实例化进行测试,再利用print打印经过该模块后的输出,查看输入输出shape是否一致,可行后即可开始对比试验其模块有效性。

ZacharyGz的博客 2937

深度学习-inception模块介绍

深度学习-inception模块介绍

self_Name_的博客 1万+

OpenCV3.3深度学习模块(DNN)应用-图像分类

OpenCV3.3深度学习模块(DNN)应用-图像分类 原创 2017-09-17 gloomyfish OpenCV学堂 DNN模块介绍 在OpenCV3.3版本发布中把DNN模块从扩展模块移到了OpenCV正式发布模块中,当前DNN模块最早来自Tiny-dnn,可以加载预先训练好的Caffe模型数据,OpenCV做了近一步扩展支持所有主流的深度学习框架训练生成与导出模型数

maweifei的博客 3223

深度学习各模块简介及作用

1、目录 1、目录 2、BatchNormalization 2.1 简介 2.2 作用 2、BatchNormalization 2.1 简介 2.2 作用   为什么要使用BatchNorm,因为效果好。经过这么简单的变换,不仅仅极大提升了训练速度,收敛过程大大加快,还提升效果。...

melon0014的博客 5858

李宏毅机器学习系列-深度学习的模块化

李宏毅机器学习系列-深度学习模块化更深的网络更好么模块化模块化在语音上的应用语音识别端到端的学习 更深的网络更好么 通常来说,我们深度越深,参数越多,表现应该越好,这个是很正常的: 但是我们也可以考虑不要深度,要宽度,如果不同的结构,同样的参数,到底哪个更好一点呢: 我们做实验之后发现深度确实是比宽度效果要好,同样深度,参数越多越好: 模块化 那为什么深的比宽的好呢,我们可以用模块化来解释啊...

王伟王胖胖的博客 1432

从原理到代码:大牛教你如何用 TensorFlow 亲手搭建一套图像识别模块

[转] http://www.leiphone.com/news/201703/JNPkCt08zJd9znzZ.html 自 2015 年 11 月首次发布以来,TensorFlow 凭借谷歌的强力支持,快速的更新和迭代,齐全的文档和教程,以及上手快且简单易用等诸多的优点,已经在图像识别、语音识别、自然语言处理、数据挖掘和预测等 AI 场景中得到了十分广泛的应用。 在

xiangz_csdn的博客 4万+

深度学习模块

欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl

谢军的博客 1190

主流开源深度学习框架对比分析

一、Caffe (Convolutional Architecture for Fast Feature Embedding) BVLC   We believe that Caffe is the fastest convnet implementation available. caffe的官网是http://caffe.berkeleyvision.org/。Caffe是一个清晰而...

weixin_34128237的博客 591

深度学习基本模块

深度学习基本模块 Optimization SGD 公式 while True: dx = compute_gradient(x) x -= learning_rate * dx SGD+Momentum 公式: ​ vx = 0 while True: dx = compute_gradient(x) vx = rho*vx+dx x -= learning_rate * vx AdaGrad AdaGrad就是在sgd的基础上除以一个项,使得在梯度变化快的地方

DCGJ666的博客 410
上一篇: 深度学习 Day19——P8YOLOv5-C3模块实现
下一篇: 深度学习 Day21——J1ResNet-50算法实战与解析
LittleRuby
博客等级 码龄7年 465粉丝 38原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值