- 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
- 🍖 原作者：K同学啊 | 接辅导、项目定制
p6:人脸识别
我的环境
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/48data/'
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_transforms = 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("D:\\AboutStudy\\jupyternote\\pytorch\\data\\48-data", transform=train_transforms)
total_data.class_to_idx
- 划分数据集
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
import torch.utils
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（可选参数）：一个可选的函数，用于初始化每个子进程的状态。这对于设置每个子进程的随机种子或其他初始化操作很有用。
二、调用官方的VGG-16模型
VGG-16（Visual Geometry Group-16）是由牛津大学视觉几何组（Visual Geometry Group）提出的一种深度卷积神经网络架构，用于图像分类和对象识别任务。VGG-16在2014年被提出，是VGG系列中的一种。VGG-16之所以备受关注，是因为它在ImageNet图像识别竞赛中取得了很好的成绩，展示了其在大规模图像识别任务中的有效性。
以下是VGG-16的主要特点：
1.深度：VGG-16由16个卷积层和3个全连接层组成，因此具有相对较深的网络结构。这种深度有助于网络学习到更加抽象和复杂的特征。
2.卷积层的设计：VGG-16的卷积层全部采用3x3的卷积核和步长为1的卷积操作，同时在卷积层之后都接有ReLU激活函数。这种设计的好处在于，通过堆叠多个较小的卷积核，可以提高网络的非线性建模能力，同时减少了参数数量，从而降低了过拟合的风险。
3.池化层：在卷积层之后，VGG-16使用最大池化层来减少特征图的空间尺寸，帮助提取更加显著的特征并减少计算量。
4.全连接层：VGG-16在卷积层之后接有3个全连接层，最后一个全连接层输出与类别数相对应的向量，用于进行分类。
VGG-16结构说明：
●13个卷积层（Convolutional Layer），分别用blockX_convX表示；
●3个全连接层（Fully connected Layer），用classifier表示；
●5个池化层（Pool layer）。
VGG-16包含了16个隐藏层（13个卷积层和3个全连接层），故称为VGG-16
from torchvision.models import vgg16
model = vgg16(pretrained = True).to(device)
for param in model.parameters():
param.requires_grad = False
model.classifier._modules['6'] = nn.Linear(4096, len(classNames))
model.to(device)
model
三、 训练模型
- 设置超参数
def adjust_lr(optimizer, epoch, start_lr):
# 每 2 个epoch衰减到原来的 0.98
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()方法产生的。
# 训练循环
# 编写训练函数
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
测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器
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所带来的的性质。
import copy
loss_fn = nn.CrossEntropyLoss()
epoches = 40
best_acc = 0
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)
if epoch_test_acc > best_acc:
best_acc = epoch_test_acc
best_model = copy.deepcopy(model)
lr = optimizer.state_dict()['param_groups'][0]['lr']
write['lr'].add_scalar("lr",lr,epoch + 1)
template = ('Epoch:{:2d}, Train_acc:{:.3f}, Train_loss:{:.3f}, Test_acc:{:.3f}, 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 = 'vgg16best_model.pth'
torch.save(model.state_dict(), PATH)
print('done')
四、 结果可视化
# 使用tensorboard
from torch.utils import tensorboard
write = {
'train_acc':tensorboard.SummaryWriter('runs/py7_logs/train_acc'),
'train_loss': tensorboard.SummaryWriter('runs/py7_logs/train_loss'),
'test_acc':tensorboard.SummaryWriter('runs/py7_logs/test_acc'),
'test_loss': tensorboard.SummaryWriter('runs/py7_logs/test_loss'),
'lr': tensorboard.SummaryWriter('runs/py7_logs/lr')
}
总结
如果我没理解错的话，这应该就是迁移学习吧，通过微调已有的模型在新的数据集上调整达到预期效果。我修改了优化器为Adam，增加了epoch到100，还增加了L1正则化，最终实现的效果是训练集70，测试集48，我的服务器出现了一些问题，所以只跑了一部分数据，后续在重新跑一下下
719
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
