第P8周—YOLOv5-C3模块实现

>- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/Nb93582M_5usednAKp_Jtw) 中的学习记录博客**
>- **🍖 原作者：[K同学啊 | 接辅导、项目定制](https://mtyjkh.blog.csdn.net/)**
>- **🚀 文章来源：[K同学的学习圈子](https://www.yuque.com/mingtian-fkmxf/zxwb45)**

 一、前期工作

1.1导入数据

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warningswarnings.filterwarnings("ignore")             #忽略警告信息device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)import os,PIL,random,pathlibdata_dir = 'D:/P8/weather_photos/'
data_dir = pathlib.Path(data_dir)data_paths  = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[3] for path in data_paths]
print(classeNames)

1.2 数据集图片标准化处理

 

1.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])
print(train_dataset, test_dataset)

1.4 设置数据加载器

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

二、搭建包含YOLOv5-C3模块的模型

import torch.nn.functional as Fdef 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-padreturn pclass Conv(nn.Module):# Standard convolutiondef __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groupssuper().__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 bottleneckdef __init__(self, c1, c2, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, shortcut, groups, expansionsuper().__init__()c_ = int(c2 * e)  # hidden channelsself.cv1 = Conv(c1, c_, 1, 1)self.cv2 = Conv(c_, c2, 3, 1, g=g)self.add = shortcut and c1 == c2def 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 convolutionsdef __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansionsuper().__init__()c_ = int(c2 * e)  # hidden channelsself.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 model_K(nn.Module):def __init__(self):super(model_K, self).__init__()# 卷积模块self.Conv = Conv(3, 32, 3, 2) # C3模块1self.C3_1 = C3(32, 64, 3, 2)# 全连接网络层，用于分类self.classifier = nn.Sequential(nn.Linear(in_features=802816, out_features=100),nn.ReLU(),nn.Linear(in_features=100, out_features=4))def forward(self, x):x = self.Conv(x)x = self.C3_1(x)x = torch.flatten(x, start_dim=1)x = self.classifier(x)return xdevice = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))model = model_K().to(device)
print(model)

上述代码定义了一个用于分类任务的PyTorch神经网络架构。

1. autopad 函数：

 autopad 函数的目的是使卷积操作的输出尺寸与输入尺寸相同，从而方便构建神经网络模型时进行 "same" 填充设置。这对于保持特征图的尺寸不变通常很有用，特别是在卷积神经网络中。

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

这部分代码定义了一个名为 `autopad` 的函数，其功能和用途是为卷积操作计算填充（padding），以实现 "same" 填充效果。让我解释这个函数的功能和参数：

- `k`：这是卷积核的大小，可以是整数或一个由两个整数组成的元组（高度和宽度）。
- `p`：这是卷积操作的填充参数，它表示在输入图像周围添加的填充量。默认情况下，它被设置为 `None`，表示填充参数未提供。

函数的主要目的是计算合适的填充值 `p`，以便在进行卷积操作时，输出的特征图尺寸与输入的特征图尺寸保持一致，实现 "same" 填充。

工作原理如下：

1. 首先检查是否提供了填充参数 `p`，如果没有提供（即 `p` 为 `None`），则执行以下操作：

2. 如果 `k` 是整数（表示卷积核是正方形的），则计算填充值 `p` 为 `k` 的一半，这将使得卷积操作在每个边上都添加一半的填充，从而使输出特征图的大小与输入相同。这是实现 "same" 填充的常见方式。

3. 如果 `k` 是一个由两个整数组成的元组，例如 `(3, 3)`（表示卷积核的高度和宽度），则计算填充值 `p` 分别为每个维度的半数。这确保了在每个维度上都应用一半的填充。

4. 最后函数返回计算得到的填充参数 `p`。

   - 这个函数用于计算卷积操作所需的填充，以实现“same”填充效果。如果没有提供 `p`（填充），则根据卷积核大小 `k` 来计算填充。如果 `k` 是整数，它会计算卷积核大小的一半；如果 `k` 是一个元组，它会计算每个维度的一半。

2. `Conv` 类：

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

代码定义了一个名为 `Conv` 的自定义卷积层类（Custom Convolutional Layer），其功能是创建一个标准的卷积层，该卷积层包括卷积操作、批归一化（Batch Normalization），以及可选的激活函数。

主要功能和参数：

- `c1`：输入通道的数量（即输入特征图的通道数）。
- `c2`：输出通道的数量（即输出特征图的通道数）。
- `k`：卷积核的大小，可以是一个整数或一个由两个整数组成的元组，分别表示卷积核的高度和宽度。
- `s`：卷积操作的步幅（stride）。
- `p`：卷积操作的填充参数。这是一个可选参数，如果不提供，将根据卷积核大小 `k` 自动计算填充，以实现 "same" 填充效果。
- `g`：分组卷积的组数（默认为1，表示普通的卷积操作）。
- `act`：激活函数，这是一个可选参数。如果设置为 `True`，将使用 SiLU（Sigmoid Linear Unit）作为激活函数。如果设置为其他激活函数的名称或激活函数模块（`nn.Module`），则会使用指定的激活函数。如果设置为 `False` 或未提供，则不应用激活函数。

该类的 `__init__` 方法在初始化过程中执行以下操作：

1. 创建一个 `nn.Conv2d` 对象，这是PyTorch内置的二维卷积层。该层的配置基于传入的参数 `c1`、`c2`、`k`、`s`、`p`、`g` 和 `bias=False`（表示不使用偏差项）。
2. 创建一个 `nn.BatchNorm2d` 对象，用于批归一化。这有助于加速训练过程并提高模型的稳定性。
3. 创建一个激活函数对象，根据 `act` 参数的值。如果 `act` 设置为 `True`，则使用 SiLU 激活函数；如果 `act` 是其他激活函数的名称或模块，将使用指定的激活函数；如果 `act` 是 `False` 或未提供，则不应用激活函数。

 `forward` 方法，该方法用于执行前向传播操作。前向传播的过程如下：

1. 输入 `x` 经过卷积操作 `self.conv`，得到卷积特征。
2. 卷积特征经过批归一化操作 `self.bn`，以进一步规范化特征。
3. 规范化后的特征经过激活函数 `self.act`，应用激活函数（如果已指定的话）。
4. 最终的输出是经过卷积、批归一化和激活函数处理的特征。

这个自定义卷积层可以嵌入到神经网络中，用于构建卷积神经网络（CNN）的不同层。通过设置不同的参数，您可以灵活地配置卷积核大小、步幅、填充、激活函数等，以满足特定的网络设计需求。

3. `Bottleneck` 类：

`Bottleneck` 模块是一个用于构建深度卷积神经网络中的瓶颈块的自定义模块。它包括了卷积操作、通道数量的缩减、快捷连接（可选）等组件，有助于增强网络的表达能力和训练效果。这种结构在许多先进的CNN架构中都得到了广泛应用。

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

上述代码定义了一个名为 `Bottleneck` 的自定义模块，用于创建标准的瓶颈块（bottleneck block），这是深度卷积神经网络（CNN）中常用的一种模块。

主要功能和参数：

- `c1`：输入通道的数量（即输入特征图的通道数）。
- `c2`：输出通道的数量（即输出特征图的通道数）。
- `shortcut`：一个布尔值，表示是否包括快捷连接（shortcut connection）。默认情况下，为 `True`，表示包括快捷连接。
- `g`：分组卷积的组数（默认为1，表示普通的卷积操作）。
- `e`：隐藏通道的扩展因子（默认为0.5），用于控制瓶颈块内部隐藏通道的数量。

`Bottleneck` 模块的主要功能是构建一个标准的瓶颈块，通常用于深度卷积神经网络（如ResNet）。它的前向传播过程如下：

1. 输入 `x` 首先通过一个 1x1 的卷积层 `self.cv1`，将输入通道数 `c1` 缩减为隐藏通道数 `c_`。这个 1x1 卷积层有助于减少计算复杂度，并且可以引入非线性变换。
2. 缩减通道数后的特征图再经过一个 3x3 的卷积层 `self.cv2`，将其变换为输出通道数 `c2`。这个卷积层是瓶颈块的核心，它有助于提取特征。
3. 如果 `shortcut` 为 `True` 且输入通道数 `c1` 等于输出通道数 `c2`，则执行快捷连接。在前向传播中，将输入 `x` 与 `self.cv2(self.cv1(x))` 相加，实现了跳跃连接。这有助于信息的直接传递，从而缓解了梯度消失问题。
4. 如果 `shortcut` 为 `False` 或者输入通道数 `c1` 不等于输出通道数 `c2`，则不执行快捷连接，直接返回 `self.cv2(self.cv1(x))`。

5.代码定义了一个神经网络模型，该模型包括卷积层、C3模块、全连接层等组件，用于图像分类任务。`C3` 模块是整个模型的关键组件，用于提取和融合多层特征，有助于提高模型的性能。可以使用此模型进行训练和图像分类。

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 model_K(nn.Module):

    def __init__(self):

        super(model_K, self).__init__()

       

        # 卷积模块

        self.Conv = Conv(3, 32, 3, 2)

       

        # C3模块1

        self.C3_1 = C3(32, 64, 3, 2)

       

        # 全连接网络层，用于分类

        self.classifier = nn.Sequential(

            nn.Linear(in_features=802816, out_features=100),

            nn.ReLU(),

            nn.Linear(in_features=100, out_features=4)

        )

       

    def forward(self, x):

        x = self.Conv(x)

        x = self.C3_1(x)

        x = torch.flatten(x, start_dim=1)

        x = self.classifier(x)

        return x

这段代码定义了两个主要的PyTorch模块类：`C3` 和 `model_K`，以及它们的组件。

 `C3` 类：
- `C3` 类代表一个具有3个卷积操作的CSP瓶颈块（CSP Bottleneck）。
- 构造函数 `__init__` 接受以下参数：
  - `c1`：输入通道数（输入特征图的通道数）。
  - `c2`：输出通道数（输出特征图的通道数）。
  - `n`：要堆叠的Bottleneck块的数量。
  - `shortcut`：一个布尔值，表示是否包括快捷连接（shortcut connection）。
  - `g`：分组卷积的组数。
  - `e`：隐藏通道的扩展因子。
- 在初始化过程中，它执行以下操作：
  - 计算隐藏通道数 `c_`，它是输出通道数 `c2` 乘以隐藏通道扩展因子 `e` 的整数部分。
  - 创建三个卷积层：`self.cv1`、`self.cv2` 和 `self.cv3`，其中 `self.cv1` 和 `self.cv2` 是1x1卷积层，`self.cv3` 是1x1卷积层，用于融合输出。
  - 创建一个包含 `n` 个 `Bottleneck` 模块的序列 `self.m`，这些模块通过堆叠来构成瓶颈块。
- 前向传播方法 `forward` 执行以下操作：
  - 输入 `x` 首先经过 `self.cv1` 和 `self.cv2` 两个1x1卷积层。
  - 通过 `self.m` 中的 `Bottleneck` 模块进行特征提取和变换。
  - 最后，特征通过 `self.cv3` 进行1x1卷积融合，然后返回。

 `model_K` 类：
- `model_K` 类代表整个神经网络模型。
- 构造函数 `__init__` 创建了以下组件：
  - 一个卷积模块 `self.Conv`，包括一个3x3卷积层，用于提取图像特征。
  - 一个 `C3` 模块 `self.C3_1`，用于进行多层特征的提取和融合。
  - 一个全连接网络层 `self.classifier`，用于最终的图像分类。
- 前向传播方法 `forward` 执行以下操作：
  - 输入 `x` 首先经过 `self.Conv` 进行卷积特征提取。
  - 通过 `self.C3_1` 进行多层特征的提取和融合。
  - 通过 `torch.flatten` 操作将特征展平，以便输入到全连接层。
  - 通过 `self.classifier` 进行分类，得到最终的输出。

运行结果：

model_K(
  (Conv): Conv(
    (conv): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (act): SiLU()
  )
  (C3_1): C3(
    (cv1): Conv(
      (conv): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (act): SiLU()
    )
    (cv2): Conv(
      (conv): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (act): SiLU()
    )
    (cv3): Conv(
      (conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (act): SiLU()
    )
    (m): Sequential(
      (0): Bottleneck(
        (cv1): Conv(
          (conv): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
        (cv2): Conv(
          (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
      )
      (1): Bottleneck(
        (cv1): Conv(
          (conv): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
        (cv2): Conv(
          (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
      )
      (2): Bottleneck(
        (cv1): Conv(
          (conv): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
        (cv2): Conv(
          (conv): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (bn): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
      )
    )
  )
  (classifier): Sequential(
    (0): Linear(in_features=802816, out_features=100, bias=True)
    (1): ReLU()
    (2): Linear(in_features=100, out_features=4, bias=True)
  )
)

三、训练函数

3.1编写训练函数

# 训练循环
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与losstrain_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()train_loss += loss.item()train_acc  /= sizetrain_loss /= num_batchesreturn train_acc, train_loss

3.2编写测试函数

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)# 计算losstarget_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  /= sizetest_loss /= num_batchesreturn test_acc, test_loss

3.3正式训练

import copyoptimizer  = torch.optim.Adam(model.parameters(), lr= 1e-4)
loss_fn    = nn.CrossEntropyLoss() # 创建损失函数epochs     = 20train_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_modelif epoch_test_acc > best_acc:best_acc   = epoch_test_accbest_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(model.state_dict(), PATH)print('Done')

3.4完整训练代码：

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warningswarnings.filterwarnings("ignore")             #忽略警告信息device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)def main():import os,PIL,random,pathlibdata_dir = 'D:/P8/weather_photos/'data_dir = pathlib.Path(data_dir)data_paths  = list(data_dir.glob('*'))classeNames = [str(path).split("\\")[3] for path in data_paths]print(classeNames)# 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/qq_38251616/article/details/124878863train_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("D:/P8/weather_photos/",transform=train_transforms)print(total_data)print(total_data.class_to_idx)train_size = int(0.8 * len(total_data))test_size  = len(total_data) - train_sizetrain_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])print(train_dataset, test_dataset)batch_size = 4train_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)import torch.nn.functional as Fdef 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-padreturn pclass Conv(nn.Module):# Standard convolutiondef __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groupssuper().__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 bottleneckdef __init__(self, c1, c2, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, shortcut, groups, expansionsuper().__init__()c_ = int(c2 * e)  # hidden channelsself.cv1 = Conv(c1, c_, 1, 1)self.cv2 = Conv(c_, c2, 3, 1, g=g)self.add = shortcut and c1 == c2def 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 convolutionsdef __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansionsuper().__init__()c_ = int(c2 * e)  # hidden channelsself.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 model_K(nn.Module):def __init__(self):super(model_K, self).__init__()# 卷积模块self.Conv = Conv(3, 32, 3, 2) # C3模块1self.C3_1 = C3(32, 64, 3, 2)# 全连接网络层，用于分类self.classifier = nn.Sequential(nn.Linear(in_features=802816, out_features=100),nn.ReLU(),nn.Linear(in_features=100, out_features=4))def forward(self, x):x = self.Conv(x)x = self.C3_1(x)x = torch.flatten(x, start_dim=1)x = self.classifier(x)return xdevice = "cuda" if torch.cuda.is_available() else "cpu"print("Using {} device".format(device))model = model_K().to(device)print(model)# 训练循环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与losstrain_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()train_loss += loss.item()train_acc  /= sizetrain_loss /= num_batchesreturn train_acc, train_lossdef 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)# 计算losstarget_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  /= sizetest_loss /= num_batchesreturn test_acc, test_lossimport copyoptimizer  = torch.optim.Adam(model.parameters(), lr= 1e-4)loss_fn    = nn.CrossEntropyLoss() # 创建损失函数epochs     = 20train_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_modelif epoch_test_acc > best_acc:best_acc   = epoch_test_accbest_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(model.state_dict(), PATH)print('Done')if __name__ == '__main__':main()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/149252.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

基于遗传算法的新能源电动汽车充电桩与路径选择（Matlab代码实现）

基于遗传算法的新能源电动汽车充电桩与路径选择（Matlab代码实现）

💥💥💞💞欢迎来到本博客❤️❤️💥💥 🏆博主优势：🌞🌞🌞博客内容尽量做到思维缜密，逻辑清晰，为了方便读者。 ⛳️座右铭&a…
阅读更多...
数据结构与算法（三）：栈与队列

数据结构与算法（三）：栈与队列

参考引用 Hello 算法 Github：hello-algo 1. 栈 1.1 栈的概念 栈（stack）是一种遵循先入后出的逻辑的线性数据结构 可以将栈类比为桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出 如下图所示&…
阅读更多...
【Pandas】数据分组groupby

【Pandas】数据分组groupby

本文目标： 应用groupby 进行分组对分组数据进行聚合,转换和过滤应用自定义函数处理分组之后的数据 文章目录 1. 数据聚合1.1 单变量分组聚合1.2 Pandas内置聚合方法1.3 聚合方法使用Numpy的聚合方法自定义方法同时计算多种特征向agg/aggregate传入字典 2. 数据转换…
阅读更多...
Gmail 将停止支持基本 HTML 视图

Gmail 将停止支持基本 HTML 视图

根据 Google 支持文档的更新内容，Gmail 将从明年 1 月起停止支持基本 HTML 视图。 ▲ Gmai 基本 HTML 视图界面 目前网页版 Gmail 提供两个界面：基本 HTML 视图和标准视图。停止支持基本 HTML 视图后，当前打开经典模式的基本 HTML 视图模式 …
阅读更多...
ChatGPT基础使用总结

ChatGPT基础使用总结

文章目录 一、ChatGPT基础概念大型语言模型LLMs---一种能够以类似人类语言的方式“说话”的软件ChatGPT定义---OpenAI 研发的一款聊天机器人程序（2022年GPT-3.5，属于大型语言模型）ChatGPT4.0---OpenAI推出了GPT系列的最新模型ChatGPT典型使用…
阅读更多...
【实操记录】Oracle数据整库同步至Apache Doris

【实操记录】Oracle数据整库同步至Apache Doris

本文是Oracle数据整库同步至Apache Doris实操记录，仅供参考 参考：https://cn.selectdb.com/blog/104 1、Oracle 配置 [rootnode1 oracle]# pwd /u01/app/oracle [rootnode1 oracle]# mkdir recovery_area [rootnode1 oracle]# chown -R oracle:dba re…
阅读更多...
CleanMyMac X4.14.1最新版本下载

CleanMyMac X4.14.1最新版本下载

CleanMyMac X是一个功能强大的Mac清理软件，它的设计理念是提供多个模块，包括垃圾清理、安全保护、速度优化、应用程序管理和文档管理粉碎等，以满足用户的不同需求。软件的界面简洁直观，让用户能够轻松进行日常的清理操作。 使用C…
阅读更多...
C/S架构学习之TCP的三次握手和四次挥手

C/S架构学习之TCP的三次握手和四次挥手

TCP的三次握手：一定由客户端主动发起的，发生在建立连接的过程中。此过程发生在客户端的connect()函数和服务器的accept()函数之间。第一次握手：客户端向服务器发送一个带有SYN标志的数据包，表示客户端请求建立连接。并且客户端会选…
阅读更多...
GEE土地分类——Property ‘B1‘ of feature ‘LE07_066018_20220603‘ is missing.错误

GEE土地分类——Property ‘B1‘ of feature ‘LE07_066018_20220603‘ is missing.错误

简介： 我正在尝试使用我在研究区域中选择的训练点对图像集合中的每个图像进行分类。就背景而言，我正在进行的项目正在研究陆地卫星生命周期内冰川面积的变化以及随后的植被变化。这意味着自 1984 年以来，我正在处理大量图像，每年一…
阅读更多...
卷积神经网络-池化层和激活层

卷积神经网络-池化层和激活层

2.池化层 根据特征图上的局部统计信息进行下采样，在保留有用信息的同时减少特征图的大小。和卷积层不同的是，池化层不包含需要学习的参数。最大池化(max-pooling)在一个局部区域选最大值作为输出，而平均池化(average pooling)计算一个局部区…
阅读更多...
Elasticsearch数据操作原理

Elasticsearch数据操作原理

Elasticsearch 是一个开源的、基于 Lucene 的分布式搜索和分析引擎，设计用于云计算环境中，能够实现实时的、可扩展的搜索、分析和探索全文和结构化数据。它具有高度的可扩展性，可以在短时间内搜索和分析大量数据。 Elasticsearch 不仅仅是一个…
阅读更多...
Apollo Planning2.0决策规划算法代码详细解析 (2): vscode gdb单步调试环境搭建

Apollo Planning2.0决策规划算法代码详细解析 (2): vscode gdb单步调试环境搭建

前言： apollo planning2.0 在新版本中在降低学习和二次开发成本上进行了一些重要的优化，重要的优化有接口优化、task插件化、配置参数改造等。 GNU symbolic debugger，简称「GDB 调试器」，是 Linux 平台下最常用的一款程序调试器。GDB 编译器通常以 gdb 命令的形式在终端…
阅读更多...
抄写Linux源码(Day14：从 MBR 到 C main 函数 (3：研究 head.s) )

抄写Linux源码(Day14：从 MBR 到 C main 函数 (3：研究 head.s) )

回忆我们需要做的事情： 为了支持 shell 程序的执行，我们需要提供： 1.缺页中断(不理解为什么要这个东西，只是闪客说需要，后边再说) 2.硬盘驱动、文件系统 (shell程序一开始是存放在磁盘里的，所以需要这两个东…
阅读更多...
vertx的学习总结7之用kotlin 与vertx搞一个简单的http

vertx的学习总结7之用kotlin 与vertx搞一个简单的http

这里我就简单的聊几句&#xff0c;如何用vertx web来搞一个web项目的 1、首先先引入几个依赖&#xff0c;这里我就用maven了&#xff0c;这个是kotlinvertx web <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apac…
阅读更多...
【C++】一文带你走入vector

【C++】一文带你走入vector

文章目录 一、vector的介绍二、vector的常用接口说明2.1 vector的使用2.2 vector iterator的使用2.3 vector空间增长问题2.4 vector 增删查改 三、总结 ヾ(๑╹◡╹)&#xff89;" 人总要为过去的懒惰而付出代价ヾ(๑╹◡╹)&#xff89;" 一、vector的介绍 vector…
阅读更多...
[C国演义] 第十三章

[C国演义] 第十三章

第十三章 三数之和四数之和 三数之和 力扣链接 根据题目要求: 返回的数对应的下标各不相同三个数之和等于0不可包含重复的三元组 – – 即顺序是不做要求的 如: [-1 0 1] 和 [0, 1, -1] 是同一个三元组输出答案顺序不做要求 暴力解法: 排序 3个for循环 去重 — — N^3, …
阅读更多...
企业微信机器人对接GPT

企业微信机器人对接GPT

现在网上大部分微信机器人项目都是基于个人微信实现的&#xff0c;常见的类库都是模拟网页版微信接口。 个人微信作为我们自己日常使用的工具&#xff0c;也用于支付场景&#xff0c;很怕因为违规而被封。这时&#xff0c;可以使用我们的企业微信机器人&#xff0c;利用企业微信…
阅读更多...
纪念在CSDN的2048天

纪念在CSDN的2048天

时间真快&#xff5e;
阅读更多...
互联网Java工程师面试题·Elasticsearch 篇·第二弹

互联网Java工程师面试题·Elasticsearch 篇·第二弹

12、详细描述一下 Elasticsearch 索引文档的过程。 协调节点默认使用文档 ID 参与计算&#xff08;也支持通过 routing &#xff09;&#xff0c;以便为路由提供合适的分片。 shard hash(document_id) % (num_of_primary_shards) 1 、当分片所在的节点接收到来自协调节点…
阅读更多...
Qt creator+cmake编译并安装

Qt creator+cmake编译并安装

1、qt creator打开项目中的CMakeLists.txt 2、修改“构建设置“-“Cmake”-”Current Configuration“&#xff0c;其中&#xff0c;安装路径为CMAKE_INSTALL_PREFIX 3、修改“构建设置“-“构建的步骤”-”目标“&#xff0c;勾选"all"和"install" 4、构…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023