深度学习训练营P9：YOLOv5-Backbone模块实现

已于 2024-05-02 19:01:11 修改
阅读量563 收藏 18
点赞数 20
文章标签： 深度学习 YOLO 人工智能
于 2024-05-02 18:56:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiaoLaJi2019/article/details/138396648
版权 
>- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客**
>- **🍖 原作者：[K同学啊](https://mtyjkh.blog.csdn.net/)**

 

前期准备和数据读取

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warnings
warnings.filterwarnings("ignore")            
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

import os,PIL,random,pathlib
data_dir = './9-data/'
data_dir = pathlib.Path(data_dir)
data_paths  = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[1] for path in data_paths]
classeNames
['cloudy', 'rain', 'shine', 'sunrise']
# 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/qq_38251616/article/details/124878863
train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    # transforms.RandomHorizontalFlip(), # 随机水平翻转
    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] 从数据集中随机抽样计算得到的。
])

test_transform = 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("./9-data/",transform=train_transforms)
total_data.class_to_idx
{'cloudy': 0, 'rain': 1, 'shine': 2, 'sunrise': 3}
train_size = int(0.8 * len(total_data))
test_size  = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])

batch_size = 4
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)

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([4, 3, 224, 224])
Shape of y:  torch.Size([4]) torch.int64

模型搭建

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)
# 统计模型参数量以及其他指标
import torchsummary as summary
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

训练模型

训练函数

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小
    num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    
    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)
        
        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # 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

测试函数

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小
    num_batches = len(dataloader)          # 批次数目, (size/batch_size，向上取整)
    test_loss, test_acc = 0, 0
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        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

正式训练

import copy

optimizer  = torch.optim.Adam(model.parameters(), lr= 1e-4)
loss_fn    = nn.CrossEntropyLoss() # 创建损失函数

epochs     = 60

train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

best_acc = 0    # 设置一个最佳准确率，作为最佳模型的判别指标

for epoch in range(epochs):
    
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
    
    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    
    # 保存最佳模型到 best_model
    if epoch_test_acc > best_acc:
        best_acc   = epoch_test_acc
        best_model = copy.deepcopy(model)
    
    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 = optimizer.state_dict()['param_groups'][0]['lr']
    
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, 
                          epoch_test_acc*100, epoch_test_loss, lr))
    
# 保存最佳模型到文件中
PATH = './best_model.pth'  # 保存的参数文件名
torch.save(best_model.state_dict(), PATH)

print('Done')
Epoch: 1, Train_acc:53.7%, Train_loss:1.151, Test_acc:65.8%, Test_loss:0.815, Lr:1.00E-04
Epoch: 2, Train_acc:63.6%, Train_loss:0.898, Test_acc:75.1%, Test_loss:0.549, Lr:1.00E-04
Epoch: 3, Train_acc:69.2%, Train_loss:0.780, Test_acc:71.6%, Test_loss:0.692, Lr:1.00E-04
Epoch: 4, Train_acc:71.7%, Train_loss:0.657, Test_acc:73.8%, Test_loss:0.830, Lr:1.00E-04
Epoch: 5, Train_acc:76.4%, Train_loss:0.586, Test_acc:84.4%, Test_loss:0.440, Lr:1.00E-04
Epoch: 6, Train_acc:79.9%, Train_loss:0.521, Test_acc:81.8%, Test_loss:0.553, Lr:1.00E-04
Epoch: 7, Train_acc:79.7%, Train_loss:0.536, Test_acc:84.0%, Test_loss:0.464, Lr:1.00E-04
Epoch: 8, Train_acc:84.9%, Train_loss:0.429, Test_acc:80.9%, Test_loss:0.481, Lr:1.00E-04
Epoch: 9, Train_acc:85.3%, Train_loss:0.403, Test_acc:89.3%, Test_loss:0.295, Lr:1.00E-04
Epoch:10, Train_acc:86.9%, Train_loss:0.368, Test_acc:88.9%, Test_loss:0.329, Lr:1.00E-04
Epoch:11, Train_acc:87.8%, Train_loss:0.346, Test_acc:81.8%, Test_loss:0.730, Lr:1.00E-04
Epoch:12, Train_acc:88.9%, Train_loss:0.318, Test_acc:95.6%, Test_loss:0.165, Lr:1.00E-04
Epoch:13, Train_acc:89.2%, Train_loss:0.293, Test_acc:93.8%, Test_loss:0.219, Lr:1.00E-04
Epoch:14, Train_acc:92.6%, Train_loss:0.222, Test_acc:90.2%, Test_loss:0.260, Lr:1.00E-04
Epoch:15, Train_acc:89.8%, Train_loss:0.249, Test_acc:95.6%, Test_loss:0.185, Lr:1.00E-04
Epoch:16, Train_acc:92.8%, Train_loss:0.193, Test_acc:89.3%, Test_loss:0.315, Lr:1.00E-04
Epoch:17, Train_acc:93.0%, Train_loss:0.191, Test_acc:89.8%, Test_loss:0.279, Lr:1.00E-04
Epoch:18, Train_acc:94.1%, Train_loss:0.151, Test_acc:92.9%, Test_loss:0.239, Lr:1.00E-04
Epoch:19, Train_acc:96.1%, Train_loss:0.118, Test_acc:90.7%, Test_loss:0.271, Lr:1.00E-04
Epoch:20, Train_acc:93.7%, Train_loss:0.205, Test_acc:93.8%, Test_loss:0.203, Lr:1.00E-04
Epoch:21, Train_acc:93.7%, Train_loss:0.141, Test_acc:91.6%, Test_loss:0.228, Lr:1.00E-04
Epoch:22, Train_acc:94.8%, Train_loss:0.123, Test_acc:94.2%, Test_loss:0.181, Lr:1.00E-04
Epoch:23, Train_acc:95.9%, Train_loss:0.117, Test_acc:92.4%, Test_loss:0.238, Lr:1.00E-04
Epoch:24, Train_acc:97.3%, Train_loss:0.089, Test_acc:89.8%, Test_loss:0.342, Lr:1.00E-04
Epoch:25, Train_acc:96.6%, Train_loss:0.088, Test_acc:88.4%, Test_loss:0.310, Lr:1.00E-04
Epoch:26, Train_acc:93.7%, Train_loss:0.204, Test_acc:90.2%, Test_loss:0.275, Lr:1.00E-04
Epoch:27, Train_acc:96.9%, Train_loss:0.085, Test_acc:92.0%, Test_loss:0.236, Lr:1.00E-04
Epoch:28, Train_acc:97.7%, Train_loss:0.062, Test_acc:92.0%, Test_loss:0.247, Lr:1.00E-04
Epoch:29, Train_acc:97.1%, Train_loss:0.091, Test_acc:92.4%, Test_loss:0.221, Lr:1.00E-04
Epoch:30, Train_acc:98.1%, Train_loss:0.044, Test_acc:91.1%, Test_loss:0.271, Lr:1.00E-04
Epoch:31, Train_acc:97.2%, Train_loss:0.090, Test_acc:94.7%, Test_loss:0.234, Lr:1.00E-04
Epoch:32, Train_acc:98.7%, Train_loss:0.041, Test_acc:94.7%, Test_loss:0.203, Lr:1.00E-04
Epoch:33, Train_acc:98.8%, Train_loss:0.056, Test_acc:91.6%, Test_loss:0.325, Lr:1.00E-04
Epoch:34, Train_acc:96.7%, Train_loss:0.088, Test_acc:94.2%, Test_loss:0.198, Lr:1.00E-04
Epoch:35, Train_acc:97.9%, Train_loss:0.068, Test_acc:93.8%, Test_loss:0.191, Lr:1.00E-04
Epoch:36, Train_acc:98.4%, Train_loss:0.037, Test_acc:91.1%, Test_loss:0.351, Lr:1.00E-04
Epoch:37, Train_acc:98.4%, Train_loss:0.055, Test_acc:91.6%, Test_loss:0.320, Lr:1.00E-04
Epoch:38, Train_acc:98.9%, Train_loss:0.040, Test_acc:93.3%, Test_loss:0.265, Lr:1.00E-04
Epoch:39, Train_acc:98.3%, Train_loss:0.042, Test_acc:88.9%, Test_loss:0.379, Lr:1.00E-04
Epoch:40, Train_acc:96.6%, Train_loss:0.082, Test_acc:91.6%, Test_loss:0.300, Lr:1.00E-04
Epoch:41, Train_acc:94.9%, Train_loss:0.155, Test_acc:91.1%, Test_loss:0.365, Lr:1.00E-04
Epoch:42, Train_acc:98.2%, Train_loss:0.060, Test_acc:88.9%, Test_loss:0.389, Lr:1.00E-04
Epoch:43, Train_acc:99.0%, Train_loss:0.025, Test_acc:93.3%, Test_loss:0.210, Lr:1.00E-04
Epoch:44, Train_acc:98.1%, Train_loss:0.040, Test_acc:92.0%, Test_loss:0.258, Lr:1.00E-04
Epoch:45, Train_acc:99.4%, Train_loss:0.022, Test_acc:94.7%, Test_loss:0.196, Lr:1.00E-04
Epoch:46, Train_acc:99.9%, Train_loss:0.007, Test_acc:95.1%, Test_loss:0.206, Lr:1.00E-04
Epoch:47, Train_acc:99.9%, Train_loss:0.007, Test_acc:96.0%, Test_loss:0.158, Lr:1.00E-04
Epoch:48, Train_acc:96.7%, Train_loss:0.088, Test_acc:94.7%, Test_loss:0.230, Lr:1.00E-04
Epoch:49, Train_acc:97.6%, Train_loss:0.077, Test_acc:93.3%, Test_loss:0.228, Lr:1.00E-04
Epoch:50, Train_acc:98.1%, Train_loss:0.060, Test_acc:90.7%, Test_loss:0.311, Lr:1.00E-04
Epoch:51, Train_acc:97.3%, Train_loss:0.082, Test_acc:90.7%, Test_loss:0.285, Lr:1.00E-04
Epoch:52, Train_acc:98.8%, Train_loss:0.045, Test_acc:91.6%, Test_loss:0.343, Lr:1.00E-04
Epoch:53, Train_acc:97.9%, Train_loss:0.076, Test_acc:92.0%, Test_loss:0.265, Lr:1.00E-04
Epoch:54, Train_acc:99.1%, Train_loss:0.032, Test_acc:94.7%, Test_loss:0.250, Lr:1.00E-04
Epoch:55, Train_acc:100.0%, Train_loss:0.007, Test_acc:95.1%, Test_loss:0.296, Lr:1.00E-04
Epoch:56, Train_acc:99.9%, Train_loss:0.009, Test_acc:95.6%, Test_loss:0.214, Lr:1.00E-04
Epoch:57, Train_acc:99.7%, Train_loss:0.008, Test_acc:95.6%, Test_loss:0.236, Lr:1.00E-04
Epoch:58, Train_acc:99.6%, Train_loss:0.012, Test_acc:92.9%, Test_loss:0.352, Lr:1.00E-04
Epoch:59, Train_acc:100.0%, Train_loss:0.003, Test_acc:95.1%, Test_loss:0.284, Lr:1.00E-04
Epoch:60, Train_acc:99.7%, Train_loss:0.006, Test_acc:93.3%, Test_loss:0.295, Lr:1.00E-04
Done

结果可视化

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

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()

模型评估

# 将参数加载到model当中
best_model.load_state_dict(torch.load(PATH, map_location=device))
epoch_test_acc, epoch_test_loss = test(test_dl, best_model, loss_fn)
epoch_test_acc, epoch_test_loss
(0.96, 0.15804262260406718)

总结

YOLO中Backbone模块简介：

1. Backbone模块的功能

Backbone模块的主要功能是从输入图像中提取有用的特征。这些特征随后会被用于预测物体的类别和位置。在深度学习中，特征提取通常通过一系列的卷积层、激活层、池化层等来完成，而Backbone模块就是由这些层构成的。

2. 常用的Backbone

在YOLO的不同版本中，Backbone有所变化。以下是一些常见的选择：

  • Darknet-53: 这是在YOLOv3中使用的Backbone，由53个卷积层组成，使用了残差连接以增强训练深度网络的能力。
  • CSPDarknet-53: 在YOLOv4中引入，通过引入跨阶段部分网络（CSP）来减少计算的重复，提高模型效率。
  • Darknet-19: 在YOLOv2中使用的较轻量级Backbone，包含19个卷积层。

3. 高级特征和创新

  • 残差连接: 如在Darknet-53中使用，帮助网络在很深的情况下仍然能有效地训练，通过允许梯度直接流过网络的某些部分来减少训练中的梯度消失问题。
  • SPP (Spatial Pyramid Pooling): 在YOLOv4中使用，能够让网络适应不同尺寸的输入图像，提取更具代表性的特征。
  • CSP: 分解特征图的计算，优化内存使用并提升速度。

4. 选择Backbone的考虑因素

选择Backbone时，需要考虑模型的效率和精度的平衡。例如，更深的网络可能提供更好的特征表达能力，但同时会增加计算成本和降低实时性能。反之，较轻量的网络虽然快速但可能牺牲精度。

 Backbone结构解析：

1. 标准卷积层（Conv）

使用卷积层进行特征提取，每个卷积层后面接一个Batch Normalization层和一个SiLU激活函数。这种配置有助于网络学习更复杂的特征表示，同时保持激活函数的非线性。

2. 残差块（Bottleneck）

这是一种残差连接的实现，允许输入跳过某些层直接连接到后面的层。这有助于缓解梯度消失问题，并使得网络能够更深入地学习而不丢失重要的输入信息。

3. CSP Bottleneck（C3）

C3模块是一种CSPNet的变体，用于降低计算成本和增强网络的学习能力。它将输入分成两部分，一部分直接通过，另一部分通过一系列的Bottleneck块，然后将它们合并回来。这种设计有助于减少参数数量和提高信息流的效率。

4. 空间金字塔池化（SPPF）

空间金字塔池化快速版（SPPF）是为了提高计算效率和处理不同尺寸的输入而设计的。它通过在不同尺度上执行最大池化，然后将这些特征图拼接起来，从而捕获不同尺度的上下文信息。

分类

这个Backbone模块的末尾包含一个分类器，该分类器通过全连接层对特征进行最终的处理，用于分类或其他下游任务。

总结

这个Backbone属于现代、高级的神经网络架构类，特别是针对复杂的视觉识别任务如物体检测。它结合了多种技术来优化性能和效率，适用于需要快速且精确处理的场合。通过引入残差连接、CSP结构和SPPF，这种架构能够有效处理深度网络常见的问题，如梯度消失和计算效率，同时保持或提高性能。

XiaoLaJi2019
关注
第P9周：YOLOv5-Backbone模块实现
Leebit_1207的博客
12-29 400
测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器。训练营往期文章中有详细的介绍。
【Pytorch】利用预训练模型初始化backbone时的常见问题及方案
Charles5101的博客
09-19 4544
在训练模型时，我们常常需要利用预训练的baseline模型对所设计网络的backbone或部分layer进行初始化，给网络训练提供一个较好的起点，同时减少训练的时间成本。比较常见的就是利用imagenet上训练好的标准网络来初始化新网络的部分层。 在进行初始化时，往往会出现两种情况：一种是待初始化的层键值和预训练模型是匹配的；一种是二者键值不匹配，在键值名称上有少许差异。 针对这两种情况，处理...
深度学习中backbone是什么东西
fangweijiex的博客
03-08 7803
backbone这个单词原意指的是人的脊梁骨，后来引申为支柱，核心的意思 在此处的意思是：主干网络 主干网络大多时候指的是提取特征的网络，其作用就是提取图片中的信息，共后面的网络使用 这些网络经常使用的是resnet VGG等，而不是我们自己设计的网络，因为这些网络已经证明了在分类等问题上的特征提取能力是很强的 在用这些网络作为backbone的时候，都是直接加载官方已经训练好的模型参数，后面接着我们自己的网络。让网络的这两个部分同时进行训练，因为加载的backbone模型已经具有提取特征的
深度学习第P9周：YOLOv5-Backbone模块实现
weixin_43414521的博客
07-19 1090
- **🍨 本文为[]中的学习记录博客**>- **🍖 原作者：[]**（类似之前介绍过的VGG1-6）。如果效果不错的话，还可以搞一篇期刊文章出来~分享一张的算法框架图，希望它可以有助于你完成本次探索~
麻醉医生的深度学习之旅 P9：YOLOv5-Backbone模块实现
u012249506的博客
07-08 598
本次实验主要是尝试运用YOLOv5算法中的Backbone模块搭建网络，对比用C3模块实现的结果，可以看到测试集的准确率有所提升，loss也更小了。以 YOLOv5s 模型为例，其主要由 Backbone、Neck 和 Head 三部分组成，网络模型见下图。Backbone主要负责对输入图像进行特征提取。Neck负责对特征图进行多尺度特征融合，并把这些特征传递给预测层。Head进行最终的回归预测。【YOLOv5】Backbone、Neck、Head各模块详解。
P9：YOLOv5-Backbone模块实现
zoey123456789的博客
06-19 932
yolov5原理详解 (涉及内容：Yolov5框架，各组件分析，特征融合是怎么实现的？yolov5的具体特征融合方式等)YOLOv5【网络结构】超详细解读总结！！！❗重点参考【目标检测】yolov5模型详解YOLOv5（You Only Look Once version 5）是一个流行的目标检测算法，它是 YOLO 系列算法的最新版本之一。YOLOv5 以其高速和高精度的特点，在实时目标检测任务中表现出色。本次构建的是基于YOLOv5l的backbone（有修改），大致如下：可以看出YOLOv5s包含。
深度学习每周学习总结P9（YOLOv5-Backbone模块实现）
qq_33489955的博客
05-23 761
数据导入及处理部分：本次数据导入没有使用torchvision自带的数据集，需要将原始数据进行处理包括数据导入，查看数据分类情况，定义transforms，进行数据类型转换等操作。划分数据集：划定训练集测试集后，再使用torch.utils.data中的DataLoader()分别加载上一步处理好的训练及测试数据，查看批处理维度.本次学习的是yolov5中BackBone模块的实现。
【Week-P9】YOLOv5-Backbone模块实现天气识别
qq_40724911的博客
02-29 943
本文使用的网络结构详细说明可以参考：（1）【YOLOv5】Backbone、Neck、Head各模块详解（2）【目标检测 YOLOv5_6.0版本总结】
yolov3-yolov4-matlab:在 MATLAB 深度学习网络中导入和导出 Darknet:trade_mark: 模型。-matlab开发
05-31
The exporter can export all the seriesNetworks and some of the backbone networks. In addition to importing the deep neural network, the importer can obtain the feature map size of the network, the n
Yolov8有效涨点：YOLOv8-AM，添加多种注意力模块提高检测精度，含代码，超详细
kay_545
02-25 4285
2023 年，Ultralytics 推出了最新版本的 YOLO 模型。注意力机制是提高模型性能最热门的方法之一。本次介绍的是YOLOv8-AM，它将注意力机制融入到原始的YOLOv8架构中。具体来说，我们分别采用四个注意力模块：卷积块注意力模块（CBAM）、全局注意力机制（GAM）、高效通道注意力（ECA）和随机注意力（SA）来设计改进模型并在数据集上进行测试。
【深度学习】（3）--损失函数
m0_74896766的博客
09-18 2313
本篇介绍了部分损失函数： 1. L1Loss损失函数：通常用于回归任务中。 2. NLLLoss损失函数：在多分类问题中广泛应用。 3. MSELoss损失函数：在多种回归任务中表现出色。 4. BCELoss损失函数：广泛应用于各类二分类任务中。 5. CrossEntropyLoss交叉熵损失函数：广泛应用于多分类问题中。
对比学习训练是如何进行的
qq_45809323的博客
09-25 296
对比学习（Contrastive Learning）是一种自监督学习的方法，旨在通过拉近相似样本的表示、拉远不相似样本的表示来学习特征表示。在训练过程中，模型并不依赖标签，而是通过样本之间的相似性进行学习。
AI学习指南深度学习篇-Adadelta算法流程
俞兆鹏的博客
09-23 643
在深度学习领域，优化算法一直是一个重要的研究方向。在训练深度神经网络时，选择合适的优化算法可以大大提高训练速度和模型性能。Adadelta算法是一种自适应学习率的优化算法，它不需要手动设置学习率，能够在训练过程中自动调整学习率，适应不同参数的变化。
用于MRI重建的具有全局感受野的傅里叶卷积块|文献速递--基于多模态-半监督深度学习的病理学诊断与病灶分割
最新发布
weixin_38594676的博客
09-26 603
在本研究中，我们提出了一种新颖的全局傅里叶卷积块（FCB），具有整个图像的感受野和较低的计算复杂度，通过将常规的空间域卷积转化为频率域实现。在本研究中，我们提出了一种新颖的全局傅里叶卷积块（FCB），具有整个图像的感受野和较低的计算复杂度，通过将常规的空间域卷积转化为频率域实现。这意味着，虽然傅里叶域中的卷积核 W 大小与输入相同，但它的空间对应物可以是一个大小为 K × K 的零填充卷积核，大小范围从 1 × 1 到输入大小 N × N 不等。顶部显示了8×加速的结果，底部显示了12×加速的结果。
深度学习与应用：行人跟踪
qz1992的专栏
09-22 687
4. 已安装软件：python版本：python 3.9，显卡驱动，cuda版本：cuda11.3 cudnn 版本：8.4.1,torch==1.12.1+cu113,torchvision= 0.13.1+cu113。- 准备多目标跟踪数据集MOT17 ，下载地址位于（Https://motchallenge.net），放置于工程路径为：（examples/val_utils/data/MOT17）3. MOT17数据集存储位置：examples/val_utils/data/MOT17。
基于深度学习的缺失数据的图像修复
weixin_42605076的博客
09-26 663
图像修复的基本目标是根据图像的上下文信息恢复缺失的部分。卷积神经网络（CNN）：CNN通过学习图像的局部特征，能够有效捕捉到图像的空间信息。模型通常在含有缺失区域的图像和相应的完整图像之间进行训练，以学习如何填补这些缺失区域。生成对抗网络（GANs）：GANs通过对抗训练的方式提高生成图像的质量。修复网络和判别网络相互竞争，修复网络努力生成真实的缺失部分，而判别网络则尝试区分修复后的图像和真实图像。这样可以生成更加自然和真实的修复结果。自编码器。
yolov5-p2网络结构
08-18
1. Backbone：yolov5-p2 使用 CSPDarknet53 作为主干网络（backbone），它由一个深度可分离卷积块和残差连接块组成。这些块可以有效地提取图像特征。 2. Neck：yolov5-p2 没有显式的 neck 结构，而是通过上采样和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值