本篇文章主要介绍了详解pytorch批训练及优化器比较，详细的介绍了什么是pytorch批训练和pytorch的optimizer优化器，非常具有实用价值，需要的朋友可以参考下
一、pytorch批训练
1. 概述
pytorch提供了一种将数据包装起来进行批训练的工具——dataloader。使用的时候，只需要将我们的数据首先转换为torch的tensor形式，再转换成torch可以识别的dataset格式，然后将dataset放入dataloader中就可以啦。
import torch import torch.utils.data as data torch.manual_seed(1) # 设定随机数种子 batch_size = 5 x = torch.linspace(1, 10, 10) y = torch.linspace(0.5, 5, 10) # 将数据转换为torch的dataset格式 torch_dataset = data.tensordataset(data_tensor=x, target_tensor=y) # 将torch_dataset置入dataloader中 loader = data.dataloader( dataset=torch_dataset, batch_size=batch_size, # 批大小 # 若dataset中的样本数不能被batch_size整除的话，最后剩余多少就使用多少 shuffle=true, # 是否随机打乱顺序 num_workers=2, # 多线程读取数据的线程数 ) for epoch in range(3): for step, (batch_x, batch_y) in enumerate(loader): print('epoch:', epoch, '|step:', step, '|batch_x:', batch_x.numpy(), '|batch_y', batch_y.numpy()) ''''' shuffle=true epoch: 0 |step: 0 |batch_x: [ 6. 7. 2. 3. 1.] |batch_y [ 3. 3.5 1. 1.5 0.5] epoch: 0 |step: 1 |batch_x: [ 9. 10. 4. 8. 5.] |batch_y [ 4.5 5. 2. 4. 2.5] epoch: 1 |step: 0 |batch_x: [ 3. 4. 2. 9. 10.] |batch_y [ 1.5 2. 1. 4.5 5. ] epoch: 1 |step: 1 |batch_x: [ 1. 7. 8. 5. 6.] |batch_y [ 0.5 3.5 4. 2.5 3. ] epoch: 2 |step: 0 |batch_x: [ 3. 9. 2. 6. 7.] |batch_y [ 1.5 4.5 1. 3. 3.5] epoch: 2 |step: 1 |batch_x: [ 10. 4. 8. 1. 5.] |batch_y [ 5. 2. 4. 0.5 2.5] shuffle=false epoch: 0 |step: 0 |batch_x: [ 1. 2. 3. 4. 5.] |batch_y [ 0.5 1. 1.5 2. 2.5] epoch: 0 |step: 1 |batch_x: [ 6. 7. 8. 9. 10.] |batch_y [ 3. 3.5 4. 4.5 5. ] epoch: 1 |step: 0 |batch_x: [ 1. 2. 3. 4. 5.] |batch_y [ 0.5 1. 1.5 2. 2.5] epoch: 1 |step: 1 |batch_x: [ 6. 7. 8. 9. 10.] |batch_y [ 3. 3.5 4. 4.5 5. ] epoch: 2 |step: 0 |batch_x: [ 1. 2. 3. 4. 5.] |batch_y [ 0.5 1. 1.5 2. 2.5] epoch: 2 |step: 1 |batch_x: [ 6. 7. 8. 9. 10.] |batch_y [ 3. 3.5 4. 4.5 5. ] '''
2. tensordataset
classtorch.utils.data.tensordataset(data_tensor, target_tensor)
tensordataset类用来将样本及其标签打包成torch的dataset，data_tensor,和target_tensor都是tensor。
3. dataloader
复制代码 代码如下:
classtorch.utils.data.dataloader(dataset, batch_size=1, shuffle=false, sampler=none,num_workers=0, collate_fn=<function default_collate>, pin_memory=false,drop_last=false)
dataset就是torch的dataset格式的对象；batch_size即每批训练的样本数量，默认为；shuffle表示是否需要随机取样本；num_workers表示读取样本的线程数。
二、pytorch的optimizer优化器
本实验中，首先构造一组数据集，转换格式并置于dataloader中，备用。定义一个固定结构的默认神经网络，然后为每个优化器构建一个神经网络，每个神经网络的区别仅仅是优化器不同。通过记录训练过程中的loss值，最后在图像上呈现得到各个优化器的优化过程。
代码实现：
import torch import torch.utils.data as data import torch.nn.functional as f from torch.autograd import variable import matplotlib.pyplot as plt torch.manual_seed(1) # 设定随机数种子 # 定义超参数 lr = 0.01 # 学习率 batch_size = 32 # 批大小 epoch = 12 # 迭代次数 x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1) y = x.pow(2) + 0.1*torch.normal(torch.zeros(*x.size())) #plt.scatter(x.numpy(), y.numpy()) #plt.show() # 将数据转换为torch的dataset格式 torch_dataset = data.tensordataset(data_tensor=x, target_tensor=y) # 将torch_dataset置入dataloader中 loader = data.dataloader(dataset=torch_dataset, batch_size=batch_size, shuffle=true, num_workers=2) 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 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.8) 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_function = torch.nn.mseloss() losses_history = [[], [], [], []] # 记录training时不同神经网络的loss值 for epoch in range(epoch): print('epoch:', epoch + 1, 'training...') for step, (batch_x, batch_y) in enumerate(loader): b_x = variable(batch_x) b_y = variable(batch_y) for net, opt, l_his in zip(nets, optimizers, losses_history): output = net(b_x) loss = loss_function(output, b_y) opt.zero_grad() loss.backward() opt.step() l_his.append(loss.data[0]) labels = ['sgd', 'momentum', 'rmsprop', 'adam'] for i, l_his in enumerate(losses_history): plt.plot(l_his, label=labels[i]) plt.legend(loc='best') plt.xlabel('steps') plt.ylabel('loss') plt.ylim((0, 0.2)) plt.show()
实验结果：
由实验结果可见，sgd的优化效果是最差的，速度很慢；作为sgd的改良版本，momentum表现就好许多；相比rmsprop和adam的优化速度就非常好。实验中，针对不同的优化问题，比较各个优化器的效果再来决定使用哪个。
三、其他补充
1. python的zip函数
zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。
x = [1, 2, 3] y = [4, 5, 6] z = [7, 8, 9] xyz = zip(x, y, z) print xyz [(1, 4, 7), (2, 5, 8), (3, 6, 9)] x = [1, 2, 3] x = zip(x) print x [(1,), (2,), (3,)] x = [1, 2, 3] y = [4, 5, 6, 7] xy = zip(x, y) print xy [(1, 4), (2, 5), (3, 6)]
相关推荐：
pytorch入门之mnist分类实例
以上就是详解pytorch批训练及优化器比较的详细内容。