p4:猴痘识别

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊 | 接辅导、项目定制

---

p4:猴痘识别

我的环境

python版本:3.11.5
pytorch版本:2.1.2
cuda版本:12.4

代码

一、 前期准备

1. 设置GPU
   如果设备上支持GPU就使用GPU,否则使用CPU

import torch
import torch.nn as nn
import torchvision
from torchvision import transforms,datasets

import os,PIL,pathlib,random

# help(pathlib)

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

# 不知道为什么加了这句才不会报错
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
`# 不知道为什么加了这句才不会报错
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"

2. 导入数据

# 定义了图像数据所在的目录路径为'data/weather_photos/'
# 将目录路径转化为pathlib路径对象，便于后续对路径进行操作。
data_dir = 'data/houdou/'
data_dir = pathlib.Path(data_dir)

# 获取指定目录下所有文件和文件夹的路径，并将其转换为列表data_paths
# 这句执行完之后的结果就是每一个子文件夹的绝对路径是列表的一项，所以后面需要切割
data_paths = list(data_dir.glob('*'))
# classNames = [str(path).split("\\")[2]for path in data_paths]
# 这句这样写更好理解
classNames = []
for path in data_paths:
    path_str = str(path) # 转字符串形式
    path_components = path_str.split("\\") # 分割
    class_name = path_components[2] # 找到子目录的名字
    classNames.append(class_name) # 加到列表中
classNames

● 第一步：使用pathlib.Path()函数将字符串类型的文件夹路径转换为pathlib.Path对象。
● 第二步：使用glob()方法获取data_dir路径下的所有文件路径，并以列表形式存储在data_paths中。
● 第三步：通过split()函数对data_paths中的每个文件路径执行分割操作，获得各个文件所属的类别名称，并存储在classeNames中
● 第四步：打印classeNames列表，显示每个文件所属的类别名称。

total_dir = 'data/houdou/'

train_trasnforms = transforms.Compose([
    transforms.Resize([224,224]),
    transforms.ToTensor(),# 常规操作
    transforms.Normalize( # 标准化处理，转化为标准正态分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

total_data = datasets.ImageFolder(total_dir,transform=train_trasnforms)
total_data
total_data.class_to_idx # 将索引和类别标签映射到对应字典

3. 划分数据集

train_size = int(0.8 *len(total_data))
test_size = len(total_data) - train_size
# 将数据集按照指定的[train_size, test_size]比例随机划分为训练集和测试集
train_dataset, test_dataset = torch.utils.data.random_split(total_data,[train_size, test_size])
train_dataset,test_dataset

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)

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

⭐torch.utils.data.DataLoader()参数详解

torch.utils.data.DataLoader 是 PyTorch 中用于加载和管理数据的一个实用工具类。它允许你以小批次的方式迭代你的数据集，这对于训练神经网络和其他机器学习任务非常有用。DataLoader 构造函数接受多个参数，下面是一些常用的参数及其解释：

1. dataset（必需参数）：这是你的数据集对象，通常是 torch.utils.data.Dataset 的子类，它包含了你的数据样本。
2. batch_size（可选参数）：指定每个小批次中包含的样本数。默认值为 1。
3. shuffle（可选参数）：如果设置为 True，则在每个 epoch 开始时对数据进行洗牌，以随机打乱样本的顺序。这对于训练数据的随机性很重要，以避免模型学习到数据的顺序性。默认值为 False。
4. num_workers（可选参数）：用于数据加载的子进程数量。通常，将其设置为大于 0 的值可以加快数据加载速度，特别是当数据集很大时。默认值为 0，表示在主进程中加载数据。
5. pin_memory（可选参数）：如果设置为 True，则数据加载到 GPU 时会将数据存储在 CUDA 的锁页内存中，这可以加速数据传输到 GPU。默认值为 False。
6. drop_last（可选参数）：如果设置为 True，则在最后一个小批次可能包含样本数小于 batch_size 时，丢弃该小批次。这在某些情况下很有用，以确保所有小批次具有相同的大小。默认值为 False.
7. timeout（可选参数）：如果设置为正整数，它定义了每个子进程在等待数据加载器传递数据时的超时时间（以秒为单位）。这可以用于避免子进程卡住的情况。默认值为 0，表示没有超时限制。
8. worker_init_fn（可选参数）：一个可选的函数，用于初始化每个子进程的状态。这对于设置每个子进程的随机种子或其他初始化操作很有用。

二、构建简单的CNN网络

对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。

上面的网络数据shape变化过程为：
3, 224, 224（输入数据）
-> 12, 220, 220（经过卷积层1）
-> 12, 216, 216（经过卷积层2）-> 12, 108, 108（经过池化层1）
-> 24, 104, 104（经过卷积层3）
-> 24, 100, 100（经过池化层4）-> 24, 50, 50（经过池化层2）
-> 60000 -> num_classes(4)

import torch.nn.functional as F

class Network_bn(nn.Module):
    def __init__(self):
        super(Network_bn,self).__init__()
        
        self.conv1 = nn.Conv2d(in_channels=3,out_channels=12,kernel_size=5,stride=1,padding=0)
        self.bn1 = nn.BatchNorm2d(12)
        self.conv2 = nn.Conv2d(in_channels=12,out_channels=12,kernel_size=5,stride=1,padding=0)
        self.bn2 = nn.BatchNorm2d(12)
        self.pool = nn.MaxPool2d(2,2)
        self.conv4 = nn.Conv2d(in_channels=12,out_channels=24,kernel_size=5,stride=1,padding=0)
        self.bn4 = nn.BatchNorm2d(24)
        self.conv5 = nn.Conv2d(in_channels=24,out_channels=24,kernel_size=5,stride=1,padding=0)
        self.bn5 = nn.BatchNorm2d(24)
        self.conv6 = nn.Conv2d(in_channels=24, out_channels=48, kernel_size=5, stride=1, padding=0)
        self.bn6 = nn.BatchNorm2d(48)
        self.conv7 = nn.Conv2d(in_channels=48, out_channels=48, kernel_size=5, stride=1, padding=0)
        self.bn7 = nn.BatchNorm2d(48)
        self.fc1 = nn.Linear(48*21*21,len(classNames))
        
    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = self.pool(x)
        x = F.relu(self.bn4(self.conv4(x)))
        x = F.relu(self.bn5(self.conv5(x)))
        x = self.pool(x)
        x = F.relu(self.bn6(self.conv6(x)))
        x = F.relu(self.bn7(self.conv7(x)))
        x = self.pool(x)
        x = x.view(-1, 48*21*21)
        x = self.fc1(x)
        
        return x
print(device)

model = Network_bn().to(device)
model

三、 训练模型

1. 设置超参数

loss_fn = nn.CrossEntropyLoss()
learn_rate = 1e-4
opt = torch.optim.SGD(model.parameters(),lr=learn_rate)
scheduler = torch.optim.lr_scheduler.CyclicLR(opt, base_lr=1e-5, max_lr=1e-3)
# 实现动态的学习率变换

2. 编写训练函数

   1. optimizer.zero_grad()

   函数会遍历模型的所有参数，通过内置方法截断反向传播的梯度流，再将每个参数的梯度值设为0，即上一次的梯度记录被清空。

   2. loss.backward()

   PyTorch的反向传播(即tensor.backward())是通过autograd包来实现的，autograd包会根据tensor进行过的数学运算来自动计算其对应的梯度。

   具体来说，torch.tensor是autograd包的基础类，如果你设置tensor的requires_grads为True，就会开始跟踪这个tensor上面的所有运算，如果你做完运算后使用tensor.backward()，所有的梯度就会自动运算，tensor的梯度将会累加到它的.grad属性里面去。

   更具体地说，损失函数loss是由模型的所有权重w经过一系列运算得到的，若某个w的requires_grads为True，则w的所有上层参数（后面层的权重w）的.grad_fn属性中就保存了对应的运算，然后在使用loss.backward()后，会一层层的反向传播计算每个w的梯度值，并保存到该w的.grad属性中。

   如果没有进行tensor.backward()的话，梯度值将会是None，因此loss.backward()要写在optimizer.step()之前。

   3. optimizer.step()

   step()函数的作用是执行一次优化步骤，通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的，所以在执行optimizer.step()函数前应先执行loss.backward()函数来计算梯度。

   注意：optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是tensor.backward()方法产生的。

# 训练循环
# 编写训练函数
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    
    train_acc, train_loss = 0, 0
    
    for X,y in dataloader:
        X, y = X.to(device), y.to(device)
        
        # 计算预测误差
        pred = model(X) 
        loss = loss_fn(pred, y)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        scheduler.step()  
        
        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    

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

测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器
4. 正式训练

1. model.train()

model.train()的作用是启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和Dropout，需要在训练时添加model.train()。model.train()是保证BN层能够用到每一批数据的均值和方差。对于Dropout，model.train()是随机取一部分网络连接来训练更新参数。

2. model.eval()

model.eval()的作用是不启用 Batch Normalization 和 Dropout。

如果模型中有BN层(Batch Normalization）和Dropout，在测试时添加model.eval()。model.eval()是保证BN层能够用全部训练数据的均值和方差，即测试过程中要保证BN层的均值和方差不变。对于Dropout，model.eval()是利用到了所有网络连接，即不进行随机舍弃神经元。

训练完train样本后，生成的模型model要用来测试样本。在model(test)之前，需要加上model.eval()，否则的话，有输入数据，即使不训练，它也会改变权值。这是model中含有BN层和Dropout所带来的的性质。

epochs = 20

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl,model,loss_fn,opt)
    write['train_acc'].add_scalar("acc",epoch_train_acc*100,epoch + 1)
    write['train_loss'].add_scalar("loss",epoch_train_loss*100,epoch + 1)
    
    model.eval()
    epoch_test_acc,epoch_test_loss = test(test_dl,model,loss_fn)
    write['test_acc'].add_scalar("acc",epoch_test_acc*100,epoch + 1)
    write['test_loss'].add_scalar("loss",epoch_test_loss*100,epoch + 1)
    
    template = ('Eposh:{:2d}, Train_scc:{:.1f}%, Train_loss:{:.3f},Test_acc:{:.1f}%,Test_loss:{:.3f}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))

四、 结果可视化

# 使用tensorboard
from torch.utils import tensorboard
write = {
    'train_acc':tensorboard.SummaryWriter('runs/py5_logs3/train_acc'),
    'train_loss': tensorboard.SummaryWriter('runs/py5_logs3/train_loss'),
    'test_acc':tensorboard.SummaryWriter('runs/py5_logs3/test_acc'),
    'test_loss': tensorboard.SummaryWriter('runs/py5_logs3/test_loss')
}

在这里插入图片描述

总结

遇到问题：

• 卷积层和池化层运算出错，导致提高模型准确率，添加卷积层时运行出现问题
• 加了两层的卷积层但是模型训练的结果最高也只到了87.9，所以后面又调整了学习率
• 最后又更改了优化器，训练效果好了很多，并且达到了88的准确率
• 最后我想说用自己的电脑跑的实在太慢了，明天我就去租！！！！