Pytorch神经网络工具箱
神经网络核心组件
- 层：神经网络的基本结构，将输入张量转换为输出张量。
- 模型：层构成的网络。
- 损失函数：参数学习的目标函数，通过最小化损失函数来学习各种参数。
- 优化器：如何使损失函数最小，这就涉及优化器。
多个层链接在一起构成一个模型或网络，输入数据通过这个模型转换为预测值，然后
损失函数把预测值与真实值进行比较，得到损失值（损失值可以是距离、概率值等），该
损失值用于衡量预测值与目标结果的匹配或相似程度，优化器利用损失值更新权重参数，
从而使损失值越来越小。这是一个循环过程，当损失值达到一个阀值或循环次数到达指定
次数，循环结束。
神经网络实例
步骤
- 利用PyTorch内置函数mnist下载数据。
- 利用torchvision对数据进行预处理，调用torch.utils建立一个数据迭代器。
- 可视化源数据。
- 利用nn工具箱构建神经网络模型。
- 实例化模型，并定义损失函数及优化器。
- 训练模型。
- 可视化结果。
使用两个隐含层，每层激活函数为ReLU，最后使用torch.max(out,1)找出张量out最大
值对应索引作为预测值。
准备数据
import torch
# 导入 PyTorch 内置的 mnist 数据
from torchvision.datasets import mnist
#导入预处理模块
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
#导入nn及优化器
import torch.nn.functional as F
import torch.optim as optim
from torch import nn
# 定义一些超参数
train_batch_size = 64
test_batch_size = 128
learning_rate = 0.01
num_epoches = 20
lr = 0.01
momentum = 0.5
#下载数据并对数据进行预处理
#定义预处理函数，这些预处理依次放在Compose函数中。
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5], [0.5])])
#下载数据，并对数据进行预处理
train_dataset = mnist.MNIST('./data', train=True, transform=transform, download=True)
test_dataset = mnist.MNIST('./data', train=False, transform=transform)
#dataloader是一个可迭代对象，可以使用迭代器一样使用。
train_loader = DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=test_batch_size, shuffle=False)
说明：
- transforms.Compose可以把一些转换函数组合在一起；
- Normalize([0.5],[0.5])对张量进行归一化，这里两个0.5分别表示对张量进行归一化
的全局平均值和方差。因图像是灰色的只有一个通道，如果有多个通道，需要有多个数
字，如3个通道，应该是Normalize([m1,m2,m3],[n1,n2,n3])； - download参数控制是否需要下载，如果./data目录下已有MNIST，可选择False；
- 用DataLoader得到生成器，这可节省内存。
可视化源数据
import matplotlib.pyplot as plt
%matplotlib inline
examples = enumerate(test_loader)
batch_idx, (example_data, example_targets) = next(examples)
fig = plt.figure()
for i in range(6):
plt.subplot(2,3,i+1)
plt.tight_layout()
plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
plt.title("Ground Truth: {}".format(example_targets[i]))
plt.xticks([])
plt.yticks([])
结果：
构建模型
#构建网络
#使用sequential构建网络，Sequential()函数功能是将网络的层组合到一起
class Net(nn.Module):
def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
super(Net, self).__init__()
self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1),nn.BatchNorm1d(n_hidden_1))
self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2),nn.BatchNorm1d (n_hidden_2))
self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim))
def forward(self, x):
x = F.relu(self.layer1(x))
x = F.relu(self.layer2(x))
x = self.layer3(x)
return x
#实例化网络
#检测是否有可用的GPU，有则使用，否则使用CPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
#实例化网络
model = Net(28 * 28, 300, 100, 10)
model.to(device)
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)
训练模型
#训练模型
# 开始训练
losses = []
acces = []
eval_losses = []
eval_acces = []
for epoch in range(num_epoches):
train_loss = 0
train_acc = 0
model.train()
#动态修改参数学习率
if epoch%5 == 0:
optimizer.param_groups[0]['lr']*=0.1
for img,label in train_loader:
img = img.to(device)
label = label.to(device)
img = img.view(img.size(0),-1)
#前向传播
out = model(img)
loss = criterion(out,label)
#反向传播
optimizer.zero_grad()
loss.backward()
optimizer.step()
#记录误差
train_loss += loss.item()
#计算分类的准确率
_, pred = out.max(1)
num_correct = (pred == label).sum().item()
acc = num_correct / img.shape[0]
train_acc+=acc
losses.append(train_loss / len(train_loader))
acces.append(train_acc / len(train_loader))
#在测试集上检验效果
eval_loss = 0
eval_acc = 0
#将模型改为预测模式
model.eval()
for img,label in test_loader:
img = img.to(device)
label = label.to(device)
img = img.view(img.size(0),-1)
out = model(img)
loss = criterion(out,label)
#记录误差
eval_loss += loss.item()
#记录准确率
_, pred = out.max(1)
num_correct = (pred == label).sum().item()
acc = num_correct / img.shape[0]
eval_acc += acc
eval_losses.append(eval_loss / len(test_loader))
eval_acces.append(eval_acc / len(test_loader))
print('epoch:{}, Train Loss:{:.4f}, Train Acc:{:.4f}, Test Loss:{:.4f}, Test Acc:{:.4f}'
.format(epoch,train_loss/len(train_loader),train_acc/len(train_loader),eval_loss / len(test_loader),eval_acc/len(test_loader)))
训练结果：
epoch: 0, Train Loss: 1.0359, Train Acc: 0.7792, Test Loss: 0.5616, Test Acc: 0.8989
epoch: 1, Train Loss: 0.4859, Train Acc: 0.8994, Test Loss: 0.3535, Test Acc: 0.9253
epoch: 2, Train Loss: 0.3507, Train Acc: 0.9193, Test Loss: 0.2756, Test Acc: 0.9382
epoch: 3, Train Loss: 0.2858, Train Acc: 0.9318, Test Loss: 0.2281, Test Acc: 0.9452
epoch: 4, Train Loss: 0.2433, Train Acc: 0.9402, Test Loss: 0.1975, Test Acc: 0.9514
epoch: 5, Train Loss: 0.2244, Train Acc: 0.9444, Test Loss: 0.1954, Test Acc: 0.9526
epoch: 6, Train Loss: 0.2193, Train Acc: 0.9462, Test Loss: 0.1899, Test Acc: 0.9535
epoch: 7, Train Loss: 0.2176, Train Acc: 0.9465, Test Loss: 0.1914, Test Acc: 0.9527
epoch: 8, Train Loss: 0.2130, Train Acc: 0.9482, Test Loss: 0.1864, Test Acc: 0.9542
epoch: 9, Train Loss: 0.2131, Train Acc: 0.9466, Test Loss: 0.1836, Test Acc: 0.9547
epoch: 10, Train Loss: 0.2092, Train Acc: 0.9484, Test Loss: 0.1866, Test Acc: 0.9540
epoch: 11, Train Loss: 0.2090, Train Acc: 0.9480, Test Loss: 0.1839, Test Acc: 0.9551
epoch: 12, Train Loss: 0.2087, Train Acc: 0.9483, Test Loss: 0.1854, Test Acc: 0.9547
epoch: 13, Train Loss: 0.2086, Train Acc: 0.9482, Test Loss: 0.1832, Test Acc: 0.9543
epoch: 14, Train Loss: 0.2077, Train Acc: 0.9483, Test Loss: 0.1845, Test Acc: 0.9544
epoch: 15, Train Loss: 0.2081, Train Acc: 0.9495, Test Loss: 0.1849, Test Acc: 0.9543
epoch: 16, Train Loss: 0.2075, Train Acc: 0.9491, Test Loss: 0.1831, Test Acc: 0.9547
epoch: 17, Train Loss: 0.2099, Train Acc: 0.9478, Test Loss: 0.1844, Test Acc: 0.9550
epoch: 18, Train Loss: 0.2086, Train Acc: 0.9486, Test Loss: 0.1835, Test Acc: 0.9537
epoch: 19, Train Loss: 0.2078, Train Acc: 0.9491, Test Loss: 0.1840, Test Acc: 0.9542
可视化训练及测试损失值：
plt.title('trainloss')
plt.plot(np.arange(len(losses)), losses)
plt.legend(['Train Loss'], loc='upper right')
构建神经网络
构建网络层
如果要对每层定义一个名称，我们可以采用Sequential的一种改进方法，在Sequential的基础上，通过add_module()添加每一层，并且为每一层增加一个单独的名字。此外，还可以在Sequential基础上，通过字典的形式添加每一层，并且设置单独的层名称。
#采用字典形式构建网络
class Net(torch.nn.Module):
def __init__(self):
super(Net4, self).__init__()
self.conv = torch.nn.Sequential(
OrderedDict(
[
("conv1", torch.nn.Conv2d(3, 32, 3, 1, 1)),
("relu1", torch.nn.ReLU()),
("pool", torch.nn.MaxPool2d(2))
]
))
self.dense = torch.nn.Sequential(
OrderedDict([
("dense1", torch.nn.Linear(32 * 3 * 3, 128)),
("relu2", torch.nn.ReLU()),
("dense2", torch.nn.Linear(128, 10))
])
)
前向传播
定义好每层后，最后还需要通过前向传播的方式把这些串起来。这就是涉及如何定义forward函数的问题。forward函数的任务需要把输入层、网络层、输出层链接起来，实现信息的前向传导。该函数的参数一般为输入数据，返回值为输出数据。
反向传播
使用nn工具箱，无须我们自己编写反向传播，直接让损失函数（loss）调用backward()即可。
训练模型
层、模型、损失函数和优化器等都定义或创建好，接下来就是训练模型。训练模型时需要注意使模型处于训练模式，即调用model.train()。调用model.train()会把所有的module设置为训练模式。如果是测试或验证阶段，需要使模型处于验证阶段，即调用model.eval()，调用model.eval()会把所有的training属性设置为False。
缺省情况下梯度是累加的，需要手工把梯度初始化或清零，调用optimizer.zero_grad()即可。训练过程中，正向传播生成网络的输出，计算输出和实际值之间的损失值。调用loss.backward()自动生成梯度，然后使用optimizer.step（）执行优化器，把梯度传播回每个网络。
如果希望用GPU训练，需要把模型、训练数据、测试数据发送到GPU上，即调用.to(device)。
神经网络工具箱nn
nn.Module
nn.Module是nn的一个核心数据结构，它可以是神经网络的某个层（Layer），也可以是包含多层的神经网络。在实际使用中，最常见的做法是继承nn.Module，生成自己的网络/层。
nn.functional
nn中的层，一类是继承了nn.Module，其命名一般为nn.Xxx（第一个是大写），如nn.Linear、nn.Conv2d、nn.CrossEntropyLoss等。另一类是nn.functional中的函数，其名称一般为nn.funtional.xxx，如nn.funtional.linear、nn.funtional.conv2d、nn.funtional.cross_entropy等。从功能来说两者相当，基于nn.Moudle能实现的层，使用
nn.funtional也可实现，反之亦然，而且性能方面两者也没有太大差异。
优化器
所有的优化方法都是继承了基类optim.Optimizer，并实现了自己的优化步骤。
#导入optim模块，实例化SGD优化器，使用动量参数momentum
import torch.optim as optim
optimizer = optim.SGD(model.parameters(),lr=lr,momentum=momentum)
#前向传播
#把输入数据传入神经网络Net实例化对象model中，自动执行forward函数，得到out输
#出值，然后用out与标记label计算损失值loss。
out = model(img)
loss = criterion(out,label)
#清空梯度
#缺省情况下，梯度是累加的，在梯度反向传播前，先需把梯度清零
optimizer.zero_grad()
#反向传播
#基于损失值，把梯度进行反向传播
loss.backward()
#更新参数
optimizer.step()
动态修改学习率参数
修改参数的方式可以通过修改参数optimizer.params_groups或新建optimizer。新建optimizer比较简单，optimizer十分轻量级，所以开销很小。但是新的优化器会初始化动量等状态信息，这对于使用动量的优化器（momentum参数的sgd）可能会造成收敛中的震荡。所以，这里直接采用修改参数optimizer.params_groups。
optimizer.param_groups：长度1的list，optimizer.param_groups[0]：长度为8的字典，包括权重参数、lr、momentum等参数。
优化器比较
#导入需要的模块
import torch
import torch.utils.data as Data
import torch.nn.functional as F
import matplotlib.pyplot as plt
%matplotlib inline
#超参数
LR = 0.01
BATCH_SIZE = 32
EPOCH = 12
#生成训练数据
#torch,unsqueeze()的作用是将一维转换为二维，torch只能处理二维的数据
x = torch.unsqueeze(torch.linspace(-1,1,1000),dim=1)
#0.1*torch.normal(x.size())增加噪点
y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size()))
torch_dataset = Data.TensorDataset(x,y)
#得到一个带批量的生成器
loader = Data.DataLoader(dataset=torch_dataset,batch_size=BATCH_SIZE,shuffle=True)
#构建神经网络
class Net(torch.nn.Module):
#初始化
def __init__(self):
super(Net,self).__init__()
self.hidden = torch.nn.Linear(1,20)
self.predict = torch.nn.Linear(20,1)
#前向传播
def forward(self,x):
x = F.relu(self.hidden(x))
x = self.predict(x)
return x
#使用多种优化器
net_SGD = Net()
net_Momentum = Net()
net_RMSProp = Net()
net_Adam = Net()
nets = [net_SGD, net_Momentum, net_RMSProp, net_Adam]
opt_SGD = torch.optim.SGD(net_SGD.parameters(), lr=LR)
opt_Momentum = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.9)
opt_RMSProp = torch.optim.RMSprop(net_RMSProp.parameters(), lr=LR, alpha=0.9)
opt_Adam = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))
optimizers = [opt_SGD, opt_Momentum, opt_RMSProp, opt_Adam]
#训练模型
loss_func = torch.nn.MSELoss()
loss_his = [[],[],[],[]] #记录损失
for epoch in range(EPOCH):
for step,(batch_x,batch_y) in enumerate(loader):
for net,opt,l_his in zip(nets,optimizers,loss_his):
output = net(batch_x)#得到每个网络的输出
loss = loss_func(output,batch_y)#计算每个网络的损失
opt.zero_grad()#清理梯度
loss.backward()#反向传播
opt.step()#应用梯度
l_his.append(loss.data.numpy())#损失记录
labels = ['SGD','Momentum','RMSprop','Adam']
#可视化
for i,l_his in enumerate(loss_his):
plt.plot(l_his,label=labels[i])
plt.legend(loc='best')
plt.xlabel('Steps')
plt.ylabel('Loss')
plt.ylim((0,0.2))
plt.show()
结果：
参考数据：《Python深度学习：基于PyTorch》
373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
