- 🍨 本文为🔗365天深度学习训练营中的学习记录博客
- 🍖 原作者：K同学啊
一、 前期准备
1. 设置GPU
如果设备上支持GPU就使用GPU,否则使用CPU
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasetsimport os,PIL,pathlibdevice = torch.device("cuda" if torch.cuda.is_available() else "cpu")devicedevice(type='cuda')
2. 导入数据
import os,PIL,random,pathlibdata_dir = './data/monkey/'
data_dir = pathlib.Path(data_dir)# 获取所有子目录路径
data_paths = list(data_dir.glob('*'))# 使用 path.parts 获取正确的目录名称
classeNames = [path.parts[-1] for path in data_paths]
print(classeNames)['Monkeypox', 'Others']
- 第一步：使用
pathlib.Path()函数将字符串类型的文件夹路径转换为pathlib.Path对象。 - 第二步：使用
glob()方法获取data_dir路径下的所有文件路径，并以列表形式存储在data_paths中。 - 第三步：通过
split()函数对data_paths中的每个文件路径执行分割操作，获得各个文件所属的类别名称，并存储在classeNames中 - 第四步：打印
classeNames列表，显示每个文件所属的类别名称
total_datadir = './data/monkey/'# 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/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)
total_dataDataset ImageFolderNumber of datapoints: 2142Root location: ./data/monkey/StandardTransform Transform: Compose(Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=True)ToTensor()Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
total_data.class_to_idx是一个存储了数据集类别和对应索引的字典。在PyTorch的ImageFolder数据加载器中，根据数据集文件夹的组织结构，每个文件夹代表一个类别，class_to_idx字典将每个类别名称映射为一个数字索引。
具体来说，如果数据集文件夹包含两个子文件夹，比如Monkeypox和Others，class_to_idx字典将返回类似以下的映射关系：{'Monkeypox': 0, 'Others': 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])
train_dataset, test_dataset(<torch.utils.data.dataset.Subset at 0x1f577f6c460>,<torch.utils.data.dataset.Subset at 0x1f57170b460>)
train_size,test_size(1713, 429)
batch_size = 32train_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网络
网络结构图（可单击放大查看）：
import torch.nn.functional as Fclass Network_bn(nn.Module):def __init__(self):super(Network_bn, self).__init__()"""nn.Conv2d()函数：第一个参数（in_channels）是输入的channel数量第二个参数（out_channels）是输出的channel数量第三个参数（kernel_size）是卷积核大小第四个参数（stride）是步长，默认为1第五个参数（padding）是填充大小，默认为0"""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.fc1 = nn.Linear(24*50*50, len(classeNames))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 = x.view(-1, 24*50*50)x = self.fc1(x)return xdevice = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))model = Network_bn().to(device)
modelUsing cuda device[10]:
Network_bn((conv1): Conv2d(3, 12, kernel_size=(5, 5), stride=(1, 1))(bn1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)(conv2): Conv2d(12, 12, kernel_size=(5, 5), stride=(1, 1))(bn2): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)(pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(conv4): Conv2d(12, 24, kernel_size=(5, 5), stride=(1, 1))(bn4): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)(conv5): Conv2d(24, 24, kernel_size=(5, 5), stride=(1, 1))(bn5): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)(fc1): Linear(in_features=60000, out_features=2, bias=True) )
三、 训练模型
1. 设置超参数
loss_fn = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-4 # 学习率
opt = torch.optim.SGD(model.parameters(),lr=learn_rate)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.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_loss3. 编写测试函数
测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器
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)# 计算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_loss4. 正式训练
epochs = 20
train_loss = []
train_acc = []
test_loss = []
test_acc = []for epoch in range(epochs):model.train()epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)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)template = ('Epoch:{:2d}, Train_acc:{:.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))
print('Done')Epoch: 1, Train_acc:62.4%, Train_loss:0.662, Test_acc:66.7%，Test_loss:0.630 Epoch: 2, Train_acc:71.0%, Train_loss:0.569, Test_acc:69.2%，Test_loss:0.569 Epoch: 3, Train_acc:74.7%, Train_loss:0.522, Test_acc:74.6%，Test_loss:0.571 Epoch: 4, Train_acc:77.1%, Train_loss:0.488, Test_acc:75.8%，Test_loss:0.520 Epoch: 5, Train_acc:80.3%, Train_loss:0.456, Test_acc:78.3%，Test_loss:0.501 Epoch: 6, Train_acc:82.3%, Train_loss:0.428, Test_acc:80.9%，Test_loss:0.466 Epoch: 7, Train_acc:83.0%, Train_loss:0.414, Test_acc:78.1%，Test_loss:0.503 Epoch: 8, Train_acc:84.9%, Train_loss:0.392, Test_acc:80.4%，Test_loss:0.432 Epoch: 9, Train_acc:85.9%, Train_loss:0.368, Test_acc:80.4%，Test_loss:0.429 Epoch:10, Train_acc:86.2%, Train_loss:0.359, Test_acc:81.4%，Test_loss:0.422 Epoch:11, Train_acc:88.3%, Train_loss:0.339, Test_acc:78.8%，Test_loss:0.454 Epoch:12, Train_acc:88.3%, Train_loss:0.331, Test_acc:82.5%，Test_loss:0.417 Epoch:13, Train_acc:89.6%, Train_loss:0.315, Test_acc:82.8%，Test_loss:0.391 Epoch:14, Train_acc:89.4%, Train_loss:0.314, Test_acc:83.2%，Test_loss:0.382 Epoch:15, Train_acc:90.1%, Train_loss:0.298, Test_acc:83.0%，Test_loss:0.423 Epoch:16, Train_acc:90.4%, Train_loss:0.290, Test_acc:84.1%，Test_loss:0.388 Epoch:17, Train_acc:90.4%, Train_loss:0.284, Test_acc:83.9%，Test_loss:0.367 Epoch:18, Train_acc:90.9%, Train_loss:0.275, Test_acc:84.4%，Test_loss:0.356 Epoch:19, Train_acc:92.5%, Train_loss:0.265, Test_acc:79.3%，Test_loss:0.429 Epoch:20, Train_acc:91.8%, Train_loss:0.260, Test_acc:85.3%，Test_loss:0.357 Done
四、 结果可视化
1. Loss与Accuracy图
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()
2. 指定图片进行预测
⭐torch.squeeze()详解
对数据的维度进行压缩，去掉维数为1的的维度
函数原型：
torch.squeeze(input, dim=None, *, out=None)
关键参数说明：
- input (Tensor)：输入Tensor
- dim (int, optional)：如果给定，输入将只在这个维度上被压缩
>>> x = torch.zeros(2, 1, 2, 1, 2)
>>> x.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x)
>>> y.size()
torch.Size([2, 2, 2])
>>> y = torch.squeeze(x, 0)
>>> y.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x, 1)
>>> y.size()
torch.Size([2, 2, 1, 2])⭐torch.unsqueeze()
对数据维度进行扩充。给指定位置加上维数为一的维度
函数原型：
torch.unsqueeze(input, dim)
关键参数说明：
- input (Tensor)：输入Tensor
- dim (int)：插入单例维度的索引
from PIL import Image classes = list(total_data.class_to_idx)def predict_one_image(image_path, model, transform, classes):test_img = Image.open(image_path).convert('RGB')# plt.imshow(test_img) # 展示预测的图片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}')
# 预测训练集中的某张照片
predict_one_image(image_path='./data/monkey/Monkeypox/M01_01_00.jpg', model=model, transform=train_transforms, classes=classes)预测结果是：Monkeypox
五、保存并加载模型
# 模型保存
PATH = './model.pth' # 保存的参数文件名
torch.save(model.state_dict(), PATH)# 将参数加载到model当中
model.load_state_dict(torch.load(PATH, map_location=device))<All keys matched successfully>
个人总结
- 前期准备：设置 GPU，若设备支持则使用 GPU，否则使用 CPU；导入 CIFAR10 数据集并划分训练集和测试集，使用数据加载器加载数据；对数据进行可视化，通过对张量进行轴变换将数据格式从 (C, H, W) 转换为 (H, W, C) 以便可视化和处理。
- 构建网络：详细介绍了构建简单 CNN 网络的过程，包括特征提取网络和分类网络。对网络中使用的
torch.nn.Conv2d、torch.nn.Linear、torch.nn.MaxPool2d等函数进行了详解，给出了关键参数说明，并展示了网络的数据形状变化过程和网络结构。 - 训练模型：设置超参数，包括损失函数和学习率等；编写训练函数和测试函数，介绍了函数中的关键步骤如
optimizer.zero_grad()、loss.backward()、optimizer.step()的作用；正式训练时，分别使用model.train()和model.eval()来启用和不启用 Batch Normalization 和 Dropout。
