- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/rnFa-IeY93EpjVu0yzzjkw) 中的学习记录博客**
- **🍖 原作者：[K同学啊](https://mtyjkh.blog.csdn.net/)**
一、前期准备
1、设置GPU
如果设备上支持GPU就使用GPU,否则使用CPU
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from torchvision import transforms, datasets
import os, PIL, pathlib, random
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device
·torchvision.transforms解析：
在 Pytorch 中 torchvision.transforms 模板提供了一系列用于图像预处理和数据增强的工具 （transforms）,这些工具可以方便对图像进行各种变换操作。
有以下几个作用：
1、数据预处理：
将原始图像数据转换成模型所需要的格式（例如：归一化、调整大小、转换为张量等）。
#举例
trans_ds = torchvision.datasets.MNIST('data',
train = True,
transform = torchvision.transforms.ToTensor(),#将数据转换成Tensor
download = True)
2、数据增强：
通过对数据图像进行随机变换（如旋转、翻转、剪裁等），增加数据多样性，防止数据过拟合。
还有其他用法，这里不详细展开。
·解析以下代码：
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
这段代码的作用是设置设备。
device : 这是一个变量，用于储存创建的Pytorch的设备对象。
torch.device() : 这个函数用于创建一个 Pytorch 的设备对象。根据条件表达式的结果，如果CUDA可用，则将设备设置为‘cuda’(即GPU)，否则设置为‘CPU’
torch.cuda.is_avaliable() : 这个函数用来检查系统中是否有可用的CUDA(GPU)设备。如果返回True,则表示系统支持CUDA,否则返回False。
简单来说，这段代码通过判断系统的GPU是否可用，来动态选择将计算任务放在GPU,还是在CPU上进行处理，以实现最佳性能。
2、导入数据
data_dir = 'E:\data\第5天-没有加密版本\第5天\weather_photos'
data_dir = pathlib.Path(data_dir) #将其转换成Path对象
data_paths = list(data_dir.glob('*')) #path_dir是Path对象；.glob()是路径匹配方法；'*'表示匹配所有的文件跟文件夹,最后将其转换从列表(list)
classeNames = [str(path).split("\\")[5] for path in data_paths] #通过split()函数将路径进行分割获得各个文件的所属名称,并存储到ClasseName
classeNames #打印每个文件的名称
步骤一：使用pathlib.Path() : 将字符串格式的文件/目录路径转换成 pathlib.Path 对象。
步骤二：使用data_dir.glob(): 获取所有的文件路径，并存储在data_paths中。
步骤三：通过split()函数对data_paths中的每个文件执行分割操作，获得各个文件所属的类别名称，并存储在classeNames中。
步骤四：打印classeNames列表，显示每个文件所属的类别名称。
import matplotlib.pyplot as plt
from PIL import Image
#指定图像文件夹路径
image_folder = 'E:\data\第5天-没有加密版本\第5天\weather_photos\cloudy'
#获取文件夹中的所有图像文件
#image是一个列表获取f；os.listdir是获取该目录（文件夹）下的所有子目录；endswith()是来判断该文件是否以括号内的格式结尾，是返回True
image_files = [f for f in os.listdir(image_folser) if f.endswith((".jpg",".png",".jpeg"))]
#创建Matplotlib图像
fig,axes = plt.subplots(3,8,figsize = (16,6)) #生成一个3行8列的子图网格
#使用列表推导式加载和显示图像
for ax,img_file in zip(axes.flat,image_files):
img_path = os.path.join(image_folder,img_file)
img = Image.open(img_path)
ax.imshow(img)
ax,axis('off')
#显示图像
plt.tight_layout()
plt.show()
axes.flat : 将axes(子图矩阵，如3行*8列)展平为一维迭代器;
os.listdir：是获取该目录（文件夹）下的所有子目录;
endswith(): 判断字符串是否以指定的后缀结尾，如果以指定后缀结尾返回 True，否则返回 False;
zip(): 将一组图像文件与对应的绘图区域（即子图）进行关联
os.path.join() : 将多个路径片段拼接成一个完整的路径;
Image.open() :打开图像文件，并将其加载为图像对象；
plt.tight_layout() : 自动调整子图的布局;
total_datadir = 'E:\data'
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]) #数据集的标准差
])
total_data = datasets.imageFolder(total_datadir,transform = train_trainsforms)
total_data
datasets.imageFolder : 自动将图像数据加载为适合训练和测试的格式，并支持多种数据预处理操作;
划分数据集
train_size = int(0.8*len(total_data)) #train_size为训练集大小，大小为总体数据大小的80%
test_size = len(total_data) - train_size #test_size为测试集大小，总数据集大小减去训练集大小
train_dataset,test_dataset = torch.utils.data.random_split(total_data,[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.dat.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
train_dl 是 DataLoader 对象，它可以对数据集进行分批处理，并且可以自动进行数据 shuffling，即打乱数据集的顺序。 在模型训练过程中，我们通常需要使用 DataLoader 来将数据分批加载到模型中进行训练。 需要注意的是，上述代码中并没有指定批次的大小，因为这个参数会在 DataLoader 初始化时进行指定。
Shape of X [N, C, H, W]:
N: Batch size (批大小，即一次处理的样本数量)
C: Channels (通道数，对于RGB图像通常是3)
H: Height (图像高度)
W: Width (图像宽度)
⭐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 Network_bn(nn.Module): #Network_bn继承了nn.Module
def __init__(self): #构建类的方法
supper(Network_bn,self).__init__() #supper是对父类进行重写
"""
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.pool1 = nn.MaxPool2d(2,2) #池化层
self.conv3 = nn.Conv2d(in_channels = 12,out_channels = 24,kernel_size = 5,stride = 1,padding = 0)
self.bn3 = nn.BatchNorm2d(24)
self.conv4 = nn.Conv2d(in_channel = 24,out_channels = 24,kernel_size = 5 , stride = 1,padding =0)
self.bn4 = nn.BatchNorm2d(24)
self.pool2 = nn.MaxPool2d(2,2)
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.pool1(x)
x = F.relu(self.bn3(self.conv3(x)))
x = F.relu(self.bn4(self.conv4(x)))
x = self.pool2(x)
x = x.view(-1,24*50*50)
x = self.fc1(x)
return x
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))
model = Network_bn.to(device)
model
⭐1. torch.nn.Conv2d()详解
函数原型：
torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)
关键参数说明：
● in_channels ( int ) – 输入图像中的通道数
● out_channels ( int ) – 卷积产生的通道数
● kernel_size ( int or tuple ) – 卷积核的大小
● stride ( int or tuple , optional ) – 卷积的步幅。默认值：1
● padding ( int , tuple或str , optional ) – 添加到输入的所有四个边的填充。默认值：0
● padding_mode (字符串,可选) – ‘zeros’, ‘reflect’, ‘replicate’或’circular’. 默认：‘zeros’
⭐2. torch.nn.Linear()详解
函数原型：
torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)
关键参数说明：
● in_features：每个输入样本的大小
● out_features：每个输出样本的大小
⭐3. torch.nn.MaxPool2d()详解
函数原型：
torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
关键参数说明：
● kernel_size：最大的窗口大小
● stride：窗口的步幅，默认值为kernel_size
● padding：填充值，默认为0
● dilation：控制窗口中元素步幅的参数
大家注意一下在卷积层和全连接层之间，我们可以使用之前是torch.flatten()也可以使用我下面的x.view()亦或是torch.nn.Flatten()。torch.nn.Flatten()与TensorFlow中的Flatten()层类似，前两者则仅仅是一种数据集拉伸操作（将二维数据拉伸为一维），torch.flatten()方法不会改变x本身，而是返回一个新的张量。而x.view()方法则是直接在原有数据上进行操作。
训练模型
设置超参数
loss_fn = nn.CrossEntropyLoss() #创建损失函数
learn_rate = 1e-4 #学习率
opt = torch.optim.SGD(model.parameters(),lr =learn_rate)
编写训练函数
#训练循环
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与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
-
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 test(dataloader,model,loss_fn):
size = len(dataloader.dataset)
num_batches = len(datalaoder)
test_acc,test_loss = 0, 0
#当不进行训练时，停止梯度更新，节省内存消耗
with torch.no_grad():
for imgs ,traget in dataloader:
imgs,traget = imags.to(device),target.to(device)
#计算loss
traget_pred = model(imgs)
loss = loss_fn(target_pred,traget)
test_loss += loss.item()
test_acc += (traget_pred.argmax(1) == target).type(torch.float).sum().item()
test_loss /= num_batches
test_acc /= size
return test_loss,test_acc
正式训练
epochs = 20
train_acc = []
train_loss = []
test_acc = []
test_loss = []
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,epoch_train_loss,epoch_test_acc,epoch_test_loss))
print('Done')
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 matplotlib.pyplot as plt
#隐藏警告
import warnings
warning.filterwarningd("ignore")
plt.rcParam['font.sans-serif'] = ['SimHei']
plt.rcParam['axes.unicode_minus'] = False
plt.rcParams['figure.dpi'] = 100
from datetime import datetime
current_time = datetime.now()
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.xlabel(current_time) # 打卡请带上时间戳，否则代码截图无效
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()
扫一扫
2000
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
