P8:在天气识别中加入YOLOv5-C3模块

最新推荐文章于 2024-05-06 10:23:59 发布

爱挠静香的下巴

最新推荐文章于 2024-05-06 10:23:59 发布

阅读量743

点赞数

分类专栏：深度学习-过程记录文章标签：深度学习神经网络人工智能

本文链接：https://blog.csdn.net/zzpl139/article/details/127910631

版权

深度学习-过程记录专栏收录该内容

18 篇文章 3 订阅

订阅专栏

🍨 本文为🔗365天深度学习训练营内部限免文章（版权归 K同学啊 所有）
🍦 参考文章地址： 🔗深度学习100例-卷积神经网络（CNN）实现mnist手写数字识别 | 第1天
🍖 作者：K同学啊 | 接辅导、程序定制

说明

一、本次大致学习了YOLOv5-C3模块
C3模块：
输入A分为两个部分，第一部分通过一个卷积层得到输出A。
第二部分则通过一个卷积层+一个瓶颈层
其中卷积层由一个二维卷积层+一个Bn层+一个SiLU激活函数构成
SiLU(x)=x⋅Sigmoid(x)
瓶颈层中采用了shortcut
shortcut为了解决深度网络的梯度发散问题
输入B与经过两次卷积的输出B进行add操作得到输出C
最后输出C和经过卷积层的输出A通过concat操作拼接

二、尝试做了一些小调整
简略记录一下
1.卷积核个数的变化
2.C3模块个数的变化
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,warnings

warnings.filterwarnings("ignore")             #忽略警告信息

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

二、查看、处理数据集

查看类别标签

import os,PIL,random,pathlib

data_dir = './data/weather_photos'
data_dir = pathlib.Path(data_dir)

data_paths  = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[2] 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("./data/weather_photos/",transform=train_transforms)
total_data

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])
train_dataset, test_dataset

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

三、模型构建

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

    def forward_fuse(self, x):
        return self.act(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 model_K(nn.Module):
    def __init__(self):
        super(model_K, self).__init__()
        
        # 卷积模块
        self.Conv = Conv(3, 16, 3, 2) 
        
        # C3模块1
        self.C3_1 = C3(16, 32, 3, 2)
        self.C3_2 = 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 = self.C3_2(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 = model_K().to(device)
model

Using cuda device
model_K(
  (Conv): Conv(
    (conv): Conv2d(3, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (act): SiLU()
  )
  (C3_1): C3(
    (cv1): Conv(
      (conv): Conv2d(16, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (act): SiLU()
    )
    (cv2): Conv(
      (conv): Conv2d(16, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (act): SiLU()
    )
    (cv3): 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()
    )
    (m): Sequential(
      (0): Bottleneck(
        (cv1): Conv(
          (conv): Conv2d(16, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
        (cv2): Conv(
          (conv): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
      )
      (1): Bottleneck(
        (cv1): Conv(
          (conv): Conv2d(16, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
        (cv2): Conv(
          (conv): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
      )
      (2): Bottleneck(
        (cv1): Conv(
          (conv): Conv2d(16, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
        (cv2): Conv(
          (conv): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
          (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (act): SiLU()
        )
      )
    )
  )
  (C3_2): 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)
  )
)

# 统计模型参数量以及其他指标
import torchsummary as summary
summary.summary(model, (3, 224, 224))

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 16, 112, 112]             432
       BatchNorm2d-2         [-1, 16, 112, 112]              32
              SiLU-3         [-1, 16, 112, 112]               0
              Conv-4         [-1, 16, 112, 112]               0
            Conv2d-5         [-1, 16, 112, 112]             256
       BatchNorm2d-6         [-1, 16, 112, 112]              32
              SiLU-7         [-1, 16, 112, 112]               0
              Conv-8         [-1, 16, 112, 112]               0
            Conv2d-9         [-1, 16, 112, 112]             256
      BatchNorm2d-10         [-1, 16, 112, 112]              32
             SiLU-11         [-1, 16, 112, 112]               0
             Conv-12         [-1, 16, 112, 112]               0
           Conv2d-13         [-1, 16, 112, 112]           2,304
      BatchNorm2d-14         [-1, 16, 112, 112]              32
             SiLU-15         [-1, 16, 112, 112]               0
             Conv-16         [-1, 16, 112, 112]               0
       Bottleneck-17         [-1, 16, 112, 112]               0
           Conv2d-18         [-1, 16, 112, 112]             256
      BatchNorm2d-19         [-1, 16, 112, 112]              32
             SiLU-20         [-1, 16, 112, 112]               0
             Conv-21         [-1, 16, 112, 112]               0
           Conv2d-22         [-1, 16, 112, 112]           2,304
      BatchNorm2d-23         [-1, 16, 112, 112]              32
             SiLU-24         [-1, 16, 112, 112]               0
             Conv-25         [-1, 16, 112, 112]               0
       Bottleneck-26         [-1, 16, 112, 112]               0
           Conv2d-27         [-1, 16, 112, 112]             256
      BatchNorm2d-28         [-1, 16, 112, 112]              32
             SiLU-29         [-1, 16, 112, 112]               0
             Conv-30         [-1, 16, 112, 112]               0
           Conv2d-31         [-1, 16, 112, 112]           2,304
      BatchNorm2d-32         [-1, 16, 112, 112]              32
             SiLU-33         [-1, 16, 112, 112]               0
             Conv-34         [-1, 16, 112, 112]               0
       Bottleneck-35         [-1, 16, 112, 112]               0
           Conv2d-36         [-1, 16, 112, 112]             256
      BatchNorm2d-37         [-1, 16, 112, 112]              32
             SiLU-38         [-1, 16, 112, 112]               0
             Conv-39         [-1, 16, 112, 112]               0
           Conv2d-40         [-1, 32, 112, 112]           1,024
      BatchNorm2d-41         [-1, 32, 112, 112]              64
             SiLU-42         [-1, 32, 112, 112]               0
             Conv-43         [-1, 32, 112, 112]               0
               C3-44         [-1, 32, 112, 112]               0
           Conv2d-45         [-1, 32, 112, 112]           1,024
      BatchNorm2d-46         [-1, 32, 112, 112]              64
             SiLU-47         [-1, 32, 112, 112]               0
             Conv-48         [-1, 32, 112, 112]               0
           Conv2d-49         [-1, 32, 112, 112]           1,024
      BatchNorm2d-50         [-1, 32, 112, 112]              64
             SiLU-51         [-1, 32, 112, 112]               0
             Conv-52         [-1, 32, 112, 112]               0
           Conv2d-53         [-1, 32, 112, 112]           9,216
      BatchNorm2d-54         [-1, 32, 112, 112]              64
             SiLU-55         [-1, 32, 112, 112]               0
             Conv-56         [-1, 32, 112, 112]               0
       Bottleneck-57         [-1, 32, 112, 112]               0
           Conv2d-58         [-1, 32, 112, 112]           1,024
      BatchNorm2d-59         [-1, 32, 112, 112]              64
             SiLU-60         [-1, 32, 112, 112]               0
             Conv-61         [-1, 32, 112, 112]               0
           Conv2d-62         [-1, 32, 112, 112]           9,216
      BatchNorm2d-63         [-1, 32, 112, 112]              64
             SiLU-64         [-1, 32, 112, 112]               0
             Conv-65         [-1, 32, 112, 112]               0
       Bottleneck-66         [-1, 32, 112, 112]               0
           Conv2d-67         [-1, 32, 112, 112]           1,024
      BatchNorm2d-68         [-1, 32, 112, 112]              64
             SiLU-69         [-1, 32, 112, 112]               0
             Conv-70         [-1, 32, 112, 112]               0
           Conv2d-71         [-1, 32, 112, 112]           9,216
      BatchNorm2d-72         [-1, 32, 112, 112]              64
             SiLU-73         [-1, 32, 112, 112]               0
             Conv-74         [-1, 32, 112, 112]               0
       Bottleneck-75         [-1, 32, 112, 112]               0
           Conv2d-76         [-1, 32, 112, 112]           1,024
      BatchNorm2d-77         [-1, 32, 112, 112]              64
             SiLU-78         [-1, 32, 112, 112]               0
             Conv-79         [-1, 32, 112, 112]               0
           Conv2d-80         [-1, 64, 112, 112]           4,096
      BatchNorm2d-81         [-1, 64, 112, 112]             128
             SiLU-82         [-1, 64, 112, 112]               0
             Conv-83         [-1, 64, 112, 112]               0
               C3-84         [-1, 64, 112, 112]               0
           Linear-85                  [-1, 100]      80,281,700
             ReLU-86                  [-1, 100]               0
           Linear-87                    [-1, 4]             404
================================================================
Total params: 80,329,608
Trainable params: 80,329,608
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 212.85
Params size (MB): 306.43
Estimated Total Size (MB): 519.85
----------------------------------------------------------------

四、模型训练测试函数

# 训练循环
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     = 20

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(model.state_dict(), PATH)

print('Done')

Epoch: 1, Train_acc:69.4%, Train_loss:1.203, Test_acc:84.9%, Test_loss:0.445, Lr:1.00E-04
Epoch: 2, Train_acc:87.3%, Train_loss:0.413, Test_acc:88.9%, Test_loss:0.338, Lr:1.00E-04
Epoch: 3, Train_acc:93.3%, Train_loss:0.180, Test_acc:90.7%, Test_loss:0.292, Lr:1.00E-04
Epoch: 4, Train_acc:96.1%, Train_loss:0.126, Test_acc:90.2%, Test_loss:0.280, Lr:1.00E-04
Epoch: 5, Train_acc:97.1%, Train_loss:0.095, Test_acc:86.7%, Test_loss:0.406, Lr:1.00E-04
Epoch: 6, Train_acc:98.2%, Train_loss:0.059, Test_acc:88.4%, Test_loss:0.520, Lr:1.00E-04
Epoch: 7, Train_acc:99.3%, Train_loss:0.024, Test_acc:88.0%, Test_loss:0.500, Lr:1.00E-04
Epoch: 8, Train_acc:96.4%, Train_loss:0.155, Test_acc:89.8%, Test_loss:0.727, Lr:1.00E-04
Epoch: 9, Train_acc:98.2%, Train_loss:0.062, Test_acc:83.6%, Test_loss:0.765, Lr:1.00E-04
Epoch:10, Train_acc:97.9%, Train_loss:0.091, Test_acc:90.7%, Test_loss:0.347, Lr:1.00E-04
Epoch:11, Train_acc:98.7%, Train_loss:0.046, Test_acc:92.0%, Test_loss:0.325, Lr:1.00E-04
Epoch:12, Train_acc:98.0%, Train_loss:0.081, Test_acc:90.2%, Test_loss:0.483, Lr:1.00E-04
Epoch:13, Train_acc:99.4%, Train_loss:0.019, Test_acc:93.8%, Test_loss:0.284, Lr:1.00E-04
Epoch:14, Train_acc:99.2%, Train_loss:0.023, Test_acc:91.1%, Test_loss:0.558, Lr:1.00E-04
Epoch:15, Train_acc:99.7%, Train_loss:0.015, Test_acc:91.6%, Test_loss:0.426, Lr:1.00E-04
Epoch:16, Train_acc:99.6%, Train_loss:0.017, Test_acc:92.0%, Test_loss:0.389, Lr:1.00E-04
Epoch:17, Train_acc:99.6%, Train_loss:0.011, Test_acc:92.9%, Test_loss:0.282, Lr:1.00E-04
Epoch:18, Train_acc:99.9%, Train_loss:0.003, Test_acc:89.8%, Test_loss:0.582, Lr:1.00E-04
Epoch:19, Train_acc:99.8%, Train_loss:0.009, Test_acc:89.8%, Test_loss:0.522, Lr:1.00E-04
Epoch:20, Train_acc:96.9%, Train_loss:0.139, Test_acc:89.8%, Test_loss:0.437, 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()

在这里插入图片描述

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

(0.9377777777777778, 0.28365869637048435)

# 查看是否与我们记录的最高准确率一致
epoch_test_acc

0.9377777777777778

爱挠静香的下巴

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
P8:在天气识别中加入YOLOv5-C3模块

在天气识别中加入YOLOv5-C3模块
复制链接

扫一扫

专栏目录