Pytorch神经网络构建与训练测试全流程入门
本文介绍几个案例，并总结其步骤的规律，便于理解训练的要点、过程并便于学习：
1. 简单线性回归程序，2. RNN构建与训练的详细步骤和套路、
3. AlexNet（CNN）采用DataLoader读取数据迭代训练的详细步骤和测试的详细步骤。
----分割线----
最基本的简单神经网络有三种构建方式：
1. 手动构建一个类
2. 用 torch.nn.Sequential()
3. 用 torch.nn.Sequential( OrderedDict )
from torch import nn # 第1种构建方法，最灵活 class Network(nn.Module): def __init__(self): super().__init__() # Inputs to hidden layer linear transformation self.hidden = nn.Linear(784, 256) # Output layer, 10 units - one for each digit self.output = nn.Linear(256, 10) # Define sigmoid activation and softmax output self.sigmoid = nn.Sigmoid() self.softmax = nn.Softmax(dim=1) def forward(self, x): # Pass the input tensor through each of our operations x = self.hidden(x) x = self.sigmoid(x) x = self.output(x) x = self.softmax(x) return x nn1 = Network() nn1
'''结果：
Network( (hidden): Linear(in_features=784, out_features=256, bias=True) (output): Linear(in_features=256, out_features=10, bias=True) (sigmoid): Sigmoid() (softmax): Softmax(dim=1) )
''' # 第2种构建方法，Sequential类 input_size = 784 hidden_size = [128, 64] output_size = 10 nn2 = nn.Sequential( nn.Linear(input_size, hidden_size[0]), nn.ReLU(), nn.Linear(hidden_size[0], hidden_size[1]), nn.ReLU(), nn.Linear(hidden_size[1], output_size), nn.Softmax(dim=1) ) nn2 '''结果：
Sequential( (0): Linear(in_features=784, out_features=128, bias=True) (1): ReLU() (2): Linear(in_features=128, out_features=64, bias=True) (3): ReLU() (4): Linear(in_features=64, out_features=10, bias=True) (5): Softmax(dim=1) )
'''
# 第3种构建方法，同样是Sequential类，但是传入字典类型，更加易用 from collections import OrderedDict nn3 = nn.Sequential(OrderedDict([ ('fc1', nn.Linear(input_size, hidden_size[0])), ('relu1', nn.ReLU()), ('fc2', nn.Linear(hidden_size[0], hidden_size[1])), ('relu2', nn.ReLU()), ('output', nn.Linear(hidden_size[1], output_size)), ('softmax', nn.Softmax(dim=1)) ])) nn3
'''结果：
Sequential(
(fc1): Linear(in_features=784, out_features=128, bias=True)
(relu1): ReLU()
(fc2): Linear(in_features=128, out_features=64, bias=True)
(relu2): ReLU()
(output): Linear(in_features=64, out_features=10, bias=True)
(softmax): Softmax(dim=1)
)
'''
然后查看模型结构的方法分别如下：
nn1 = Network() nn1 print(nn1.hidden) print(nn2[2]) print(nn3[4]) print(nn3.output) ''' Linear(in_features=784, out_features=256, bias=True) Linear(in_features=128, out_features=64, bias=True) Linear(in_features=64, out_features=10, bias=True) Linear(in_features=64, out_features=10, bias=True) '''
模型训练与测试的全流程。
案例1：最简单的学习模型——线性回归。
## linear regression simply implement # https://blog.csdn.net/qq_27492735/article/details/89707150 import torch from torch import nn, optim from torch.autograd import Variable # 读取训练数据，这里不读取了，直接定义一个最简单的数据x及其标签y x = Variable(torch.Tensor([[1, 2], [3, 4], [4, 2]]), requires_grad=False) y = Variable(torch.Tensor([[3], [7], [6]]), requires_grad=False) # model constract def model(): # 模型 net = nn.Sequential( nn.Linear(2, 4), nn.ReLU6(), nn.Linear(4, 3), nn.ReLU(), nn.Linear(3, 1) ) # 优化器与损失函数 optimizer = optim.Adam(net.parameters(), lr=0.01) loss_fun =nn.MSELoss() # 迭代步骤 for i in range(300): # 1 前向传播 out = net(x) # 2 计算损失 loss = loss_fun(out, y) print(loss) # 3 梯度清零 optimizer.zero_grad() # 4 反向传播 loss.backward() # 5 更新优化器 optimizer.step() # 计算预测值 print(net(x)) # 保存训练好的模型（参数） # torch.save(net, 'simplelinreg.npy') return net net = model()
以上模型大概是最简单的了，毕竟没有比线性回归更简单的机器学习模型了。
案例2： RNN循环神经网络的搭建以及训练流程。
我通常把pytorch训练神经网络细分为8个步骤，或者3个部分。
第1部分：声明 1 模型 Model、2 损失函数 Loss function、3 优化器 Optimizer
第2部分：读取数据通常都是采用DataLoader做的，不过简单的任务直接用 numpy 定义就行。比较大规模的任务都用DataLoader进行批量处理。4 前向传播。
第3部分：更新参数，通常是固定的三个操作 5 计算损失函数 6 optimizer.zero_grad() 、7 loss.backward()、8 optimizer.step()。
""" torch.nn.RNN() input_size: hidden_size: num_layers: nonlinearity: 指定非线性函数的使用[tanh, relu]，默认tanh bias: True default, dropout:如果非%gui除了最后一层之外其他层输出都会套上一个drouput层 batch_first: if True, Tensor的shape就是(batch, seq, feature)，输出也是 bidirectional: False default """ import numpy as np import matplotlib.pyplot as plt import torch from torch import nn # from torch.autograd import Variable """ PyTorch基础入门七：PyTorch搭建循环神经网络(RNN) https://blog.csdn.net/out_of_memory_error/article/details/81456501 Example：曲线拟合。拟合一个cos函数 """ class RNNCurveFitting(nn.Module): def __init__(self, INPUT_SIZE): super(RNNCurveFitting, self).__init__() self.rnn = nn.RNN( input_size=INPUT_SIZE, hidden_size=32, num_layers=1, batch_first=True ) self.out = nn.Linear(32, 1) def forward(self, x, h_state): r_out, h_state = self.rnn(x, h_state) outs = [] for time in range(r_out.size(1)): outs.append(self.out(r_out[:, time, :])) return torch.stack(outs, dim=1), h_state # hyper parameters TIME_STEP=10 INPUT_SIZE=1 LR = 0.02 # Step1 model model = RNNCurveFitting(INPUT_SIZE) # Step2 3 loss function and optimizer loss_func = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=LR) h_state = None for step in range(300): start, end = step * np.pi, (step+1)*np.pi steps = np.linspace(start, end, TIME_STEP, dtype=np.float32) x_np = np.sin(steps) y_np = np.cos(steps) # Step (4) 如果用的DataLoader则不需要这一步骤， read data, from_numpy: 数组转换成张量，所得tensor和原array共享内存 x = torch.from_numpy(x_np[np.newaxis, :, np.newaxis]) y = torch.from_numpy(y_np[np.newaxis, :, np.newaxis]) # x = Variable(torch.from_numpy(x_np[np.newaxis, :, np.newaxis])) # y = Variable(torch.from_numpy(y_np[np.newaxis, :, np.newaxis])) # Step 4 前向传播 prediction, h_state = model(x, h_state) h_state = h_state.data # Step 5 6 7 8 loss = loss_func(prediction, y) optimizer.zero_grad() loss.backward() optimizer.step() plt.plot(steps, y_np.flatten(), 'r-') plt.plot(steps, prediction.data.numpy().flatten(), 'b-') plt.show()
3：关于DataLoader的使用。
首先用 torchvision.datasets.MNIST 数据集为例
import torchvision import torch import torchvision.transforms as transforms import torchvision train_set = torchvision.datasets.MNIST(root="./mnist_data",train=True,download=True) test_set = torchvision.datasets.MNIST(root="./mnist_data",train=False,download=True) #pil型对象显示 print(test_set.classes) print(test_set[0]) for i in range(10): img,label=test_set[i] print(test_set.classes[label]) img.show() ''' ['0 - zero', '1 - one', '2 - two', '3 - three', '4 - four', '5 - five', '6 - six', '7 - seven', '8 - eight', '9 - nine'] (<PIL.Image.Image image mode=L size=28x28 at 0x290E792BE80>, 7) ''' batch_size = 256 # Data loader train_loader = torch.utils.data.DataLoader(dataset=train_set, batch_size=batch_size, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_set, batch_size=batch_size, shuffle=False)
自己构建DataLoader：
1. 如上图，可以直接用 torch.vision.datasets 提供的现成的 DataSet
2. ImageFolder 类读取图像文件夹，其中图像的文件名就是标签
3. 自定义：需要定义本地文件的读取，关键是self属性里定义的读取路径、data路径列表、label列表，然后在__getitem__()中定义文件读取。
# reference:https://blog.csdn.net/weixin_48249563/article/details/114318425 transform = transforms.Compose([transforms.ToTensor(), transforms.Resize([596, 1220])]) class SpectrogramSet(Dataset): def __init__(self, transform): self._root = "D://datasets/medical-spectrogram/" self._classes = ["Crackle_Coarse", "Crackle_Fine", "normal", "Wheezes"] self._imgs = list() self._label = list() self._get_all_imgpath() self._transform = transform def __getitem__(self, index): image_path = self._imgs[index] image = Image.open(image_path) if self._transform is not None: image = self._transform(image) return image, self._label[index] def __len__(self): return len(self._label) def _get_all_imgpath(self): idx = 0 for c in self._classes: cur_dir = os.path.join(self._root, c) cur_imgs = [os.path.join(cur_dir, path) for path in os.listdir(cur_dir)] self._imgs.extend(cur_imgs) self._label.extend([idx]*len(cur_imgs)) idx += 1 datasets = SpectrogramSet(transform) data_loader = torch.utils.data.DataLoader(datasets, batch_size=BATCH_SIZE,shuffle=True) # ------- 测试 DataLoader 是否正确 ----------- for i, (inputs, target) in enumerate(data_loader): if i == 0: # 输出一部分看看 print(inputs.shape) print(target) plt.figure(figsize=(12, 16)) for num in range(12): # 确认图像是否可以正确读取 plt.subplot(3, 4, num + 1) plt.imshow(inputs[num].permute([1, 2, 0])) plt.title(target[num], size=13) plt.axis('off') plt.tight_layout() plt.show() else: break
一种更好的实现方式：
# reference:https://blog.csdn.net/weixin_48249563/article/details/114318425 transform = transforms.Compose([transforms.ToTensor(), transforms.Resize([596, 1220])]) class SpectrogramSet(Dataset): def __init__(self, datas, labels, transform): self._root = "D://datasets/medical-spectrogram/" self._classes = ["Crackle_Coarse", "Crackle_Fine", "normal", "Wheezes"] self._imgs = datas self._label = labels self._transform = transform def __getitem__(self, index): image = Image.open(self._imgs[index]) if self._transform is not None: image = self._transform(image) return image, self._label[index] def __len__(self): return len(self._label) def idx2class(): return {'0': "Crackle_Coarse", '1':"Crackle_File", '2':"normal", '3':"Wheezes"} def get_train_valid_test(): root = "D://datasets/medical-spectrogram/" # 0 1 2 3 classes = ["Crackle_Coarse", "Crackle_Fine", "normal", "Wheezes"] imgs = list() labels = list() idx = 0 for c in classes: cur_dir = os.path.join(root, c) cur_paths = [os.path.join(cur_dir, path) for path in os.listdir(cur_dir)] imgs.extend(cur_paths) labels.extend([idx]*len(cur_paths)) idx += 1 # imgs = random.shuffle(imgs) # labels = random.shuffle(labels) random.shuffle(imgs) random.shuffle(labels) si = len(imgs) train_imgs, val_imgs, test_imgs = [], [], [] train_labels, val_labels, test_labels = [], [], [] for img, la in zip(imgs[:int(si*0.8)], labels[:int(si*0.8)]): train_imgs.append(img) train_labels.append(la) for img, la in zip(imgs[int(si*0.8):int(si*0.9)], labels[int(si*0.8):int(si*0.9)]): val_imgs.append(img) val_labels.append(la) for img, la in zip(imgs[int(si*0.9):], labels[int(si*0.9):]): test_imgs.append(img) test_labels.append(la) train_loader = torch.utils.data.DataLoader(SpectrogramSet(train_imgs, train_labels, transform), batch_size=BATCH_SIZE,drop_last=True,shuffle=True) val_loader = torch.utils.data.DataLoader(SpectrogramSet(val_imgs, val_labels, transform), batch_size=BATCH_SIZE,drop_last=True,shuffle=True) test_loader = torch.utils.data.DataLoader(SpectrogramSet(test_imgs, test_labels, transform), batch_size=BATCH_SIZE,shuffle=False) loader = {"train": train_loader, "val": val_loader, "test": test_loader} return loader
案例3：AlexNet
(1) 通过本地数据集构建DataLoader。本地文件目录结构如下：
E:.
├─test
│ ├─cat
│ └─dog
├─train_0
│ ├─cat
│ └─dog
└─val
├─cat
└─dog
所谓DataLoader是一个对数据集进行抽象建模的类，其构造参数为集合，规定好了每次读取的批量batch_size，也在构建时指定需不需要打乱数据。
ImageFolder是通过文件目录创建图像数据集的类，构造参数为 文件夹路径、图像变换操作类的实例。
import os from PIL import Image import torch from torchvision import transforms from torchvision.datasets import ImageFolder def get_dataloader(): BATCH_SIZE = 256 normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) path_1 = r"e:/DATAS/catdogclass/train_0" trans_1 = transforms.Compose([ transforms.Resize((65, 65)), transforms.ToTensor(), normalize, ]) train_set = ImageFolder(root=path_1, transform=trans_1) train_loader = torch.utils.data.DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True, num_workers=0) path_2 = r"e:/DATAS/catdogclass/test" trans_2 = transforms.Compose([ transforms.Resize((65, 65)), transforms.ToTensor(), normalize, ]) test_set = ImageFolder(root=path_2, transform=trans_2) test_loader = torch.utils.data.DataLoader(test_set, batch_size=BATCH_SIZE, shuffle=True, num_workers=0) path_3 = r"e:/DATAS/catdogclass/val" valid_set = ImageFolder(root=path_3, transform=trans_2) valid_loader = torch.utils.data.DataLoader(valid_set, batch_size=BATCH_SIZE, shuffle=True, num_workers=0) print(train_set.classes) print(train_set.class_to_idx) return train_loader, test_loader, valid_loader
(2) 训练和测试的函数封装。训练和测试区别在于，测试一步到位，不需要梯度信息、不需要反向传播、不需要调整优化器参数。只是前向传播然后计算损失函数而已。
def train_model(model, device, train_loader, optimizer, epoch): train_loss = 0 model.train() for batch_index, (data, label) in enumerate(train_loader): data, label = data.to(device), label.to(device) # Step 6 optimizer.zero_grad() # Step 4 5 output = model(data) loss = loss_fn(output, label) # Step 7 8 loss.backward() optimizer.step() if batch_index % 400 == 0: train_loss = loss.item() print('Train Epoch:{}\tbatch_index:{}\ttrain loss:{:.6f}'.format(epoch,batch_index,loss.item())) return train_loss def test_model(model, device, test_loader): model.eval() correct = 0.0 test_loss = 0.0 with torch.no_grad(): for data, label in test_loader: data, label = data.to(device), label.to(device) # Step 4 5 output = model(data) test_loss += loss_fn(output, label).item() # get result pred = output.argmax(dim=1) correct += pred.eq(label.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) print('Test_average_loss:{:.4f},Accuracy:{:3f}\n'.format( test_loss,100*correct/len(test_loader.dataset) )) acc = 100*correct/len(test_loader.dataset) return test_loss, acc
(3) AlexNet模型构建
import torch import torch.nn as nn class AlexNet(nn.Module): def __init__(self, num_classes=2): super(AlexNet, self).__init__() self.features = nn.Sequential( nn.Conv2d(3, 48, kernel_size=11), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(48, 128, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(128, 192, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(192, 192, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.Conv2d(192, 128, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), ) self.classifier = nn.Sequential( nn.Linear(6*6*128, 2048), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(2048, 2048), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(2048, num_classes), ) def forward(self, x): x = self.features(x) x = torch.flatten(x, start_dim=1) # convert tensor to 1-dim x = self.classifier(x) return x
(4) 主程序
# necessary dependencies 必要依赖 import os import torch from torch import nn, optim from torch.nn import functional as F from PIL import Image import torchvision.transforms as transforms from torchvision.datasets import ImageFolder # basic hyper parameters 必要的超参数 DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") EPOCH = 2 BATCH_SIZE = 256 # 局部变量，存储中间结果，即损失函数值得变化值 reslist = [] Train_Loss_list = [] Valid_Loss_list = [] Valid_Accuracy_list = []
# get DataLoader 获取数据集实例 train_loader, test_loader, valid_loader = get_dataloader() # 训练步骤 # Step 1 2 3 model = AlexNet().to(DEVICE) optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=0.0005) loss_fn = F.cross_entropy # 多个Epoch迭代训练 for epoch in range(1, EPOCH + 1): # 训练集训练 train_loss = train_model(model, DEVICE, train_loader, optimizer, epoch) Train_Loss_list.append(train_loss) torch.save(model, os.path.join(model_path, 'catdogclassifi-%s.pth' % epoch)) # 验证集进行验证 test_loss, acc = test_model(model, DEVICE, valid_loader) Valid_Loss_list.append(test_loss) Valid_Accuracy_list.append(acc) reslist.append(test_loss) min_num = min(reslist) min_index = reslist.index(min_num) print('model%s' % (min_index + 1)) print('验证集最高准确率： ') print('{}'.format(Valid_Accuracy_list[min_index]))
(5) 测试集，该步骤和验证集几乎一样，区别在于，模型训练过程中采用验证集进行测试，并在训练过程中反馈信息，引导训练，而训练过程中不可以知道测试集的信息，否则相当于“考试中泄题”了，则最终对训练好的模型进行测试就不会有正确的效果。测试集须在模型完全训练完毕后再使用。
# 取最好的进入测试集进行测试 model = torch.load(r'./pthfiles/catdogclassifi-%s.pth' % (min_index + 1)) model.eval() accuracy = test_model(model, DEVICE, test_loader) print('测试集准确率') print('{}%'.format(accuracy)) res_plot(range(0, EPOCH), Train_Loss_list, ValueError, Valid_Accuracy_list)
end
