- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者：K同学啊 | 接辅导、项目定制
p4:猴痘识别
我的环境
python版本:3.11.5
pytorch版本:2.1.2
cuda版本:12.4
代码
一、 前期准备
- 设置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"
- 导入数据
# 定义了图像数据所在的目录路径为'data/weather_photos/'
# 将目录路径转化为pathlib路径对象，便于后续对路径进行操作。
data_dir = 'data/shoes'
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列表，显示每个文件所属的类别名称。
train_trasforms = transforms.Compose([
transforms.Resize([224,224]),
torchvision.transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
])
test_trasforms = transforms.Compose([
transforms.Resize([224,224]),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
])
train_dataset = datasets.ImageFolder("data/shoes/train", transform=train_trasforms)
test_dataset = datasets.ImageFolder("data/shoes/test", transform=test_trasforms)
train_dataset.class_to_idx # 将索引和类别标签映射到对应字典
- 划分数据集
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 构造函数接受多个参数，下面是一些常用的参数及其解释：
- dataset（必需参数）：这是你的数据集对象，通常是 torch.utils.data.Dataset 的子类，它包含了你的数据样本。
- batch_size（可选参数）：指定每个小批次中包含的样本数。默认值为 1。
- shuffle（可选参数）：如果设置为 True，则在每个 epoch 开始时对数据进行洗牌，以随机打乱样本的顺序。这对于训练数据的随机性很重要，以避免模型学习到数据的顺序性。默认值为 False。
- num_workers（可选参数）：用于数据加载的子进程数量。通常，将其设置为大于 0 的值可以加快数据加载速度，特别是当数据集很大时。默认值为 0，表示在主进程中加载数据。
- pin_memory（可选参数）：如果设置为 True，则数据加载到 GPU 时会将数据存储在 CUDA 的锁页内存中，这可以加速数据传输到 GPU。默认值为 False。
- drop_last（可选参数）：如果设置为 True，则在最后一个小批次可能包含样本数小于 batch_size 时，丢弃该小批次。这在某些情况下很有用，以确保所有小批次具有相同的大小。默认值为 False.
- timeout（可选参数）：如果设置为正整数，它定义了每个子进程在等待数据加载器传递数据时的超时时间（以秒为单位）。这可以用于避免子进程卡住的情况。默认值为 0，表示没有超时限制。
- worker_init_fn（可选参数）：一个可选的函数，用于初始化每个子进程的状态。这对于设置每个子进程的随机种子或其他初始化操作很有用。
二、构建简单的CNN网络
对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。
import torch.nn.functional as F
class Model(nn.Module):
def __init__(self):
super(Model,self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(3, 12, kernel_size=5, padding=0),
nn.BatchNorm2d(12),
nn.ReLU()
)
self.conv2 = nn.Sequential(
nn.Conv2d(12, 12, kernel_size=5, padding=0),
nn.BatchNorm2d(12),
nn.ReLU()
)
self.pool3 = nn.Sequential(
nn.MaxPool2d(2)
)
self.conv4 = nn.Sequential(
nn.Conv2d(12, 24, kernel_size=5, padding=0),
nn.BatchNorm2d(24),
nn.ReLU()
)
self.conv5 = nn.Sequential(
nn.Conv2d(24, 24, kernel_size=5, padding=0),
nn.BatchNorm2d(24),
nn.ReLU()
)
self.pool6 = nn.Sequential(
nn.MaxPool2d(2)
)
self.dropout = nn.Sequential(
nn.Dropout(0.2)
)
self.fc = nn.Sequential(
nn.Linear(24*50*50, len(classNames))
)
def forward(self,x):
batch_size = x.size(0)
x = self.conv1(x)
x = self.conv2(x)
x = self.pool3(x)
x = self.conv4(x)
x = self.conv5(x)
x = self.pool6(x)
x = self.dropout(x)
x = x.view(batch_size, -1)
x = self.fc(x)
return x
model = Model().to(device)
model
# 训练函数
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset)
num_batches = len(dataloader)
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)
optimizer.zero_grad()
loss.backward()
optimizer.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
def test(dataloader, model, loss_fn):
size = len(dataloader.dataset)
num_batches = len(dataloader)
test_loss, test_acc = 0, 0
with torch.no_grad():
for imgs, target in dataloader:
imgs,target = imgs.to(device), target.to(device)
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_loss /= num_batches
test_acc /= size
return test_acc, test_loss
三、 训练模型
- 自动调节学习率
def adjust_lr(optimizer, epoch, start_lr):
lr = start_lr * (0.92 ** (epoch // 2))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
learn_rate = 1e-4
optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)
-
编写训练函数
- optimizer.zero_grad()
函数会遍历模型的所有参数，通过内置方法截断反向传播的梯度流，再将每个参数的梯度值设为0，即上一次的梯度记录被清空。
- 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()之前。
- optimizer.step()
step()函数的作用是执行一次优化步骤，通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的，所以在执行optimizer.step()函数前应先执行loss.backward()函数来计算梯度。
注意：optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是tensor.backward()方法产生的。
# 正式训练
loss_fn = nn.CrossEntropyLoss()
epoches = 40
for epoch in range(epoches):
adjust_lr(optimizer, epoch, learn_rate)
model.train()
epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
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)
lr = optimizer.state_dict()['param_groups'][0]['lr']
write['lr'].add_scalar("lr",lr,epoch + 1)
template = ('Epoch:{:2d}, Train_acc:{:.3f}, Train_loss:{:.1f}, Test_acc:{:.1f}, Test_loss:{:.3f}, Lr:{:.2E}')
print(template.format(epoch+1, epoch_train_acc, epoch_train_loss, epoch_test_acc, epoch_test_loss, lr))
print('done')
测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器
4. 正式训练
- model.train()
model.train()的作用是启用 Batch Normalization 和 Dropout。
如果模型中有BN层(Batch Normalization）和Dropout，需要在训练时添加model.train()。model.train()是保证BN层能够用到每一批数据的均值和方差。对于Dropout，model.train()是随机取一部分网络连接来训练更新参数。
- 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所带来的的性质。
四、 结果可视化
# 使用tensorboard
from torch.utils import tensorboard
write = {
'train_acc':tensorboard.SummaryWriter('runs/py6_logs1/train_acc'),
'train_loss': tensorboard.SummaryWriter('runs/py6_logs1/train_loss'),
'test_acc':tensorboard.SummaryWriter('runs/py6_logs1/test_acc'),
'test_loss': tensorboard.SummaryWriter('runs/py6_logs1/test_loss'),
'lr': tensorboard.SummaryWriter('runs/py6_logs1/lr')
}
总结
在更改了优化器由SGD改为Adam后，测试集的最高准确率达到了百分之九十，这一次的学习中，我学会了如何自动调节学习率，以及各种官方调用方法。
23
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
