【PyTorch深度学习60分钟快速入门 】Part1：PyTorch是什么？来源：https://www.cnblogs.com/leejack/p/8370634.html
import torch
import numpy as np #用于替代NumPy（torch对象叫张量，带前缀和括号，并用逗号分隔，numpy对象叫数组，用空格分隔），#torch可以使用GPU的计算力,一种深度学习研究平台，可以提供最大的灵活性和速度
x = torch.Tensor(5, 3) #创建一个5x3且未初始化的矩阵,如果将首字母大写的Tensor改成小写tensor，会报错
#print(x)
x = torch.rand(5, 3)#创建一个随机初始化的矩阵rand表示0~1之间均匀分布的随机数
#print(x)
#print(x.size())
y = torch.rand(5, 3)
#print(x + y)
#print(torch.add(x, y))
result = torch.Tensor(5, 3)
#print(result)
torch.add(x, y, out=result)
#print(result)
y.add_(x) #原地替换，任何原地改变张量值的操作后缀都是固定的_，例如：x.copy_(y)、x.t_()，都将原地改变x的值。
#print(y)
x = torch.randn(4, 4)
y = x.view(16) #调整或重塑张量形状，使用torch.view,相当于numpy中的reshape
z = x.view(-1, 8) # the size -1 is inferred from other dimensions,-1和2结果一样，可以从其size中看出来（2，8）
print(y,z)
print(x.size(), y.size(), z.size())
a = torch.ones(5)#ones和numpy中的ones一样
print("a:",a)
b = a.numpy()#将torch张量对象转换为numpy中的数组对象
print("b:",b)
a = np.ones(5)
b = torch.from_numpy(a)#将numpy中的数组对象转换为torch张量对象，b=a.torch()不可以，只能用torch.from_numpy(?)
#在CPU上的所有的张量，除了CharTensor之外，都支持转换成NumPy对象，也支持反向转换。
np.add(a, 1, out=a)#将a +1后 再回传给a
print('a:',a)
print('b:',b)
if torch.cuda.is_available():#使用.cuda函数可以将张量移到GPU上进行计算
x = x.cuda()
y = y.cuda()
x + y
else:
print('cuda is not available')
tensor([ 0.3856, -0.3865, -0.5026, 0.8776, -2.5368, -1.7295, 0.0219, 1.2241,
1.4038, -0.8838, -0.1019, 2.1651, -0.3457, -0.5027, 0.0651, 0.1814]) tensor([[ 0.3856, -0.3865, -0.5026, 0.8776, -2.5368, -1.7295, 0.0219, 1.2241],
[ 1.4038, -0.8838, -0.1019, 2.1651, -0.3457, -0.5027, 0.0651, 0.1814]])
torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])
a: tensor([1., 1., 1., 1., 1.])
b: [1. 1. 1. 1. 1.]
a: [2. 2. 2. 2. 2.]
b: tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
cuda is not available
#【PyTorch深度学习60分钟快速入门 】Part2：Autograd自动化微分，
#在PyTorch中，集中于所有神经网络的是autograd包。
#autograd.Variable是autograd包的核心类，它封装了一个张量，并支持几乎所有在该张量上定义的操作。
#一旦完成了你的计算，你可以调用.backward()，它会自动计算所有梯度。你可以通过.data属性访问原始的张量，而梯度w.r.t.这个变量被累积到.grad。
#还有一个类对于autograd的实现非常重要——一个函数。变量和函数是相互联系的，并建立一个非循环图，它编码了计算的一个完整历史。
#每个变量都有一个.grad_fn属性，该属性引用了一个创建了该变量的函数（除了由用户创建的变量之外，它们的grad_fn是None）。
#如果你想计算导数，你可以在一个变量上调用.backward()。如果变量是一个标量（也就是说它包含一个元素数据），那么你不需要为backward()指定任何参数，
#但是如果它是矢量，有更多元素，那么你需要指定一个grad_output参数，该参数是一个匹配形状的张量。
import torch
from torch.autograd import Variable
x = Variable(torch.ones(2, 2), requires_grad=True)#创建一个变量：
y = x + 2
z = y * y * 3#对y做更多的操作
out = z.mean()
print(x,y,z,out)#在打印出来的结果中，x值的后面携带了是否要求梯度的信息，y，z，out的值后面则各携带了一个grad_fn的编号，按计算公式名称和顺序编号
print(y.grad_fn,z.grad_fn,out.grad_fn)#y,z,out是由于操作而创建的，所以它各自都有一个grad_fn,相应的编号和地址参见打印结果
#现在我们介绍后向传播
#backward函数是反向求导数，使用链式法则求导，如果是标量则可以直接求导，
#对矢量(即多维变量)y求导，需要额外指定grad_tensors，grad_tensors的shape必须和y的相同
#y.backward(torch.Tensor(2,2)) #y可以和out或者z同时求梯度，没有冲突
#z.backward(torch.Tensor(2,2)) #z和out不能同时求梯度会报错，有冲突
out.backward()#out.backward()等效于做out.backward(torch.Tensor([1.0])),若括号里面改成torch.Tensor([1.0,1.0]结果会依次增加4.5，为什么?
print(x.grad)#打印梯度d(out)/dx， 梯度（Gradients）即导数或偏导数, z=3(x+2)^2,out对xi的偏导数=3（xi+2）/2，xi=1，所以结果=4.5
print("*********************************************************")
#backward函数中还有retain_graph参数 ，使用retain_graph参数的时候，再次求导的时候，会对之前的导数进行累加
#如果默认不设置即requires_grad=None，则会报错，无法反向求导2次
x=Variable(torch.Tensor([1,5,6,10,16]),requires_grad=True) #需要求导数
y=x*x
weights0=torch.ones(5)
y.backward(weights0,retain_graph=True)
print(x.grad)
weights1=torch.FloatTensor([0.1,0.1,0.1,0.1,0.1])
y.backward(weights1,retain_graph=True)
print(x.grad)
weights2=torch.FloatTensor([0.5,0.1,0.1,0.1,0.2])
y.backward(weights2,retain_graph=True)
print(x.grad)
print("*********************************************************")
#你可以利用梯度做很多疯狂的事情！
x = torch.randn(3)#生成均值为0，标准差为1的3个标准正态分布，一维张量
x = Variable(x, requires_grad=True)
y = x * 2
while y.data.norm() < 1000:#括号未写内容默认为求2范数，关于范数的解释见下面代码
y = y * 2 #2的n次方，当n达到10的时候，y=1024
print(y)
gradients = torch.FloatTensor([0.1, 1.0, 10])#因为x=torch.randn(3)是3个数，所以需要给出3个权重
y.backward(gradients)
print(x.grad) #y对x的导数就是2的n次方
print("*********************************************************")
#范数(norm)是数学中的一种基本概念。在泛函分析中，它定义在赋范线性空间中，并满足一定的条件，即①非负性；②齐次性；③三角不等式。
#它常常被用来度量某个向量空间（或矩阵）中的每个向量的长度或大小。
#常用的三种p-范数推导出的矩阵范数：
#1-范数：║A║1 = max{ ∑|ai1|，∑|ai2|，……，∑|ain| } （列和范数，A每一列元素绝对值之和的最大值）
#（其中∑|ai1|第一列元素绝对值的和∑|ai1|=|a11|+|a21|+...+|an1|，其余类似）；
#2-范数：║A║2 = A的最大奇异值 = (max{ λi(AH*A) }) 1/2 （谱范数，即A^H*A特征值λi中最大者λ1的平方根，其中AH为A的转置共轭矩阵）；
#∞-范数：║A║∞ = max{ ∑|a1j|，∑|a2j|,...，∑|amj| } （行和范数，A每一行元素绝对值之和的最大值）（其中∑|a1j| 为第一行元素绝对值的和，其余类似）；
#其它的p-范数则没有很简单的表达式。
a = torch.ones((2,3)) #建立tensor
a1 = torch.norm(a,p=1) #指定求1范数,等价于a1 = a.data.norm(p=1)
a2 = torch.norm(a) #默认求2范数,等价于a2 = a.data.norm(p=2)
print(a)
print(a1)
print(a2)
#求指定维度上的范数，返回输入张量给定维dim 上每行的p 范数
a = torch.tensor([[1, 2, 3, 4],[1, 2, 3, 4]]).float() #norm仅支持floatTensor,a是一个2*4的Tensor
a0 = torch.norm(a,p=2,dim=0) #按0维度求2范数，按列
a1 = torch.norm(a,p=2,dim=1) #按1维度求2范数，按行
print(a0)
print(a1)
#可以看输出，dim=0是对0维度上的一个向量求范数，返回结果数量等于其列的个数，也就是说有多少个0维度的向量，将得到多少个范数。dim=1同理。
#再看keepdim，其含义是保持输出的维度，挺抽象的，我们还是通过具体例子来看吧。
a = torch.rand((2,3,4))
at = torch.norm(a,p=2,dim=1,keepdim=True) #保持维度
af = torch.norm(a,p=2,dim=1,keepdim=False) #不保持维度,默认为false，经过计算后3维降为2维
print(a.shape)
print(at.shape)
print(af.shape)
tensor([[1., 1.],
[1., 1.]], requires_grad=True) tensor([[3., 3.],
[3., 3.]], grad_fn=<AddBackward0>) tensor([[27., 27.],
[27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward1>)
<AddBackward0 object at 0x00000000061D8278> <MulBackward0 object at 0x000000000995FC50> <MeanBackward1 object at 0x000000000995FDA0>
tensor([[4.5000, 4.5000],
[4.5000, 4.5000]])
*********************************************************
tensor([ 2., 10., 12., 20., 32.])
tensor([ 2.2000, 11.0000, 13.2000, 22.0000, 35.2000])
tensor([ 3.2000, 12.0000, 14.4000, 24.0000, 41.6000])
*********************************************************
tensor([-810.8790, -148.9206, -800.3726], grad_fn=<MulBackward0>)
tensor([ 51.2000, 512.0000, 5120.0000])
*********************************************************
tensor([[1., 1., 1.],
[1., 1., 1.]])
tensor(6.)
tensor(2.4495)
tensor([1.4142, 2.8284, 4.2426, 5.6569])
tensor([5.4772, 5.4772])
torch.Size([2, 3, 4])
torch.Size([2, 1, 4])
torch.Size([2, 4])
#【PyTorch深度学习60分钟快速入门 】Part3：神经网络
#神经网络可以通过使用torch.nn包来构建。
#既然你已经了解了autograd，而nn依赖于autograd来定义模型并对其求微分。一个nn.Module包含多个网络层，以及一个前向函数forward(input)
#例如，查看下图中，对图片分类的网络：图片参见https://www.cnblogs.com/leejack/p/8387771.html
#这是一个简单的前馈网络。它接受输入，并将输入依次通过多个层，然后给出输出结果。对于神经网络来说，一个经典的训练过程包括以下步骤：
#定义一个包含一些可学习的参数（或权重）的神经网络，对输入数据集进行迭代，通过网络处理输入，计算损失函数（即输出距离正确值差多远）
#将梯度传播回网络参数，更新网络的权重，通常使用一个简单的更新规则：weight = weight - learning_rate * gradient
#下面，我们定义该网络：
import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module): #所定义的Net是从nn.Module框架中继承而来的，而不是一个新玩意
def __init__(self):#定义一个初始化函数，当调用这个Net的时候，内部会进行初始化
super(Net, self).__init__() #等价于nn.Module.__init__(self)这里首先初始化（清空）所定义的网络
#以下是配置网络内容及参数：本例中配置了两次卷积和三次全连接(前馈神经网络也称为全连接或多层感知器)，前馈函数单独定义，不含在初始化里面。
# 1 input image channel, 6 output channels, 5x5 square convolution，# kernel
self.conv1 = nn.Conv2d(1, 6, 5) #"1"是图像通道，kernel 5(自定义边长5*5)，经卷积后size变成(（n-(5-1)),(n-(5-1)）)，6层是自定义的吗？
self.conv2 = nn.Conv2d(6, 16, 5)#16层是自定义的吗？
# an affine operation: y = Wx + b 全连接层，又名仿射层，输出y和输入x满足y=Wx +b,W和b是可以学习的参数，后续可以调用参数来获得W和b的值
self.fc1 = nn.Linear(16 * 5 * 5, 120) #原图片32*32像素经过两次卷积和两次池化后大小变成了5*5，共有16个。120是自定义的吗？
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):#定义前向forward函数，引出自变量x,返回计算结果return x，反向（backward）函数使用autograd自动定义，在前向函数中可使用任何张量操作。
# Max pooling over a (2, 2) window 通过（2，2）的最大池化操作以后，行数和列数就变成了原来的一半（因为是2个中选择一个大的）
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) #先调用kernal卷积conv1计算一次，再由激活函数relu计算一次，最后再经过最大池化计算一次
# If the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), 2)#接上一步，将经过一轮计算的x再调用conv2计算一次，再relu一次，再最大池化一次
x = x.view(-1, self.num_flat_features(x)) #将x的size统一变成二维，其中用-1表示组数，可以自适应原先的组数，其余的合并，具体参见下方解释，
x = F.relu(self.fc1(x))#调用上面定义好size的线性函数fc1计算一次，然后再relu一次
x = F.relu(self.fc2(x))#继续调用fc2计算一次，然后再relu一次
x = self.fc3(x)#最后再做一次线性fc3,最终的结果就是二维的，反向求导时尽管是10个特征值，out.backward(torch.randn(1, 10))，若写（10）不行
return x
def num_flat_features(self, x): #特征扁平化处理，这段函数的目的就是为了将特征重构
size = x.size()[1:] #[1：],其中的1：就是将除了第一维的组数保留外，其余全部通过下面的乘法计算总数，并利用上面的view(-1,)合并成2维
# all dimensions except the batch dimension, x.size()[开始值:结尾值]，反馈x有几维，取其中几维的值
#比如x=torch.rand((2,3,4))，则x.size()等效于x.size()[0:3]为[2，3，4]，x.size()[1:]为[3，4]，x.size()[1:3]为[3,4]
num_features = 1
for s in size:
num_features *= s
return num_features
net = Net()
print(net)
print("***********************************************************")
def num_flat_features(x):
size = x.size()[1:]
# all dimensions except the batch dimension, x.size()[开始值:结尾值]，反馈x有几维，取其中几维的值
#比如x=torch.rand((2,3,4))，则x.size()等效于x.size()[0:3]为[2，3，4]，x.size()[1:]为[3，4]，x.size()[1:3]为[3,4]
num_features = 1
for s in size:
num_features *= s
return num_feature
x=torch.rand(2,3,5)
x.view(-1,num_flat_features(x))
print(x,num_flat_features(x),x.size())
print(x.view(-1,num_flat_features(x)))
print("***********************************************************")
#一个模型的可学习参数由net.parameters()返回
params = list(net.parameters())
print(len(params)) #上面构造的前馈神经网络共计包含10个参数，net return x的结果中恰好也是10个值
print(params[1])
#params[0].size()四维[6,1,5,5]，表示6个大组，每个大组有1个小组（增加一个方括号而已），每小组内有25个(5*5)数据conv1's .weight， 每次运行值不一样，值是如何设定的？
#params[1].size()一维[6]，表示6个值，tensor([ 0.1707, 0.1464, -0.0306, -0.1523, -0.1115, 0.0629],requires_grad=True)值每次运行也会变，值是如何设定的？
#params[2].size()四维[16,6,5,5]，表示16个大组，每个大组有6个小组，每小组内有25个(5*5)数据conv2's .weight，每次运行值不一样，值是如何设定的？
#params[3].size()一维[16]，表示16个值，tensor([-0.0175, 0.0498, -0.0686, ...， -0.0419],requires_grad=True),每次运行值不一样，值是如何设定的？
#params[4].size()二维[120,400]，表示120个组，每组400个数据的列表:W1
#params[5].size()一维[120]，表示120个值:b1
#params[6].size()二维[84,120],表示84个组，每组120个数据的列表:W2
#params[7].size()一维[84],表示84个值:b2
#params[8].size()二维[10,84],表示10个组，每组84个数据的列表:W3
#params[9].size()一维[10],表示10个值:b3，tensor([-0.0595, -0.0891, 0.0139, ..., -0.0213], requires_grad=True),每次运行值不一样
print("***********************************************************")
#前向输入是一个autograd.Variable，输出也是如此。
#注意：该网络（LeNet）的预期输入大小为32x32。要在MNIST数据集上使用该网络，需要将该数据集中的图片大小调整为32x32。
input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
print(out)
print("***********************************************************")
#将所有参数的梯度缓冲区置为零，并使用随机梯度进行后向传播：
net.zero_grad()
out.backward(torch.randn(1, 10))
#注意： torch.nn只支持小批量，整个torch.nn包都只支持小批量样本的输入，而不支持单个样本。
#例如，nn.Conv2d将接受一个4维的张量nSamples x nChannels x Height x Width。
#如果你只有单个样本，那么只需要使用input.unsqueeze(0)来添加一个假的批量维度。
#简要回顾：
#torch.Tensor：一个多维数组。
#autograd.Variable：封装了一个张量和对该张量操作的记录历史。除了与张量具有相同的API外，还拥有一些如backward()等的操作。
#此外，还持有对张量的梯度w.r.t.。
#nn.Module：神经网络模块。一种封装参数的便捷方式，并含有将参数移到GPU、导出、加载等的辅助功能。
#nn.Parameter：一种变量，当作为一个属性分配给一个模块时，它会自动注册为一个参数。
#autograd.Function：实现autograd操作的前向和后向定义。每个变量操作，至少创建一个单独的函数节点，连接到创建了一个变量的函数，并对其历史进行编码。
#0x02 损失函数（Loss Function）损失函数接受（输出，目标）输入对，并计算一个值，该值能够评估输出与目标的偏差大小。
#nn包中有几个不同的损失函数。一个简单的损失函数是nn.MSELoss，它会计算输入和目标之间的均方误差。
output = net(input)
target = Variable(torch.arange(1., 11.))
# 虚拟目标举个例子 a dummy target, for example,arange函数中的数字要加小数点，否则会报错，左开右闭，output有10个所以target也10个
criterion = nn.MSELoss()#MSE就是两者差的平方和除以样本数量10，这里没有用自由度即10-1=9这个值,不能直接将参数output和target输入MSEloss（）的括号中
loss = criterion(output, target)
print("loss:",loss)
#现在，如果你沿着后向跟踪损失，那么可以使用它的`.grad_fn属性，你将会看到一个这样的计算图：
#input ->conv2d ->relu ->maxpool2d ->conv2d ->relu ->maxpool2d ->view ->linear ->relu ->linear ->relu ->linear ->MSELoss ->loss
#所以，当我们调用loss.backward()时，整个计算图是对损失函数求微分后的，并且图中所有的变量将使自己的.grad变量与梯度进行累积。
#为了便于展示，我们反向跟随几步：
print(loss.grad_fn) # MSELoss
print(loss.grad_fn.next_functions[0][0]) # Linear 为什么要加参数[0][0]，去掉一个[0]也可以得到一个值，但是会多出一个“（，0）”
print(loss.grad_fn.next_functions[0][0].next_functions[0][0]) # ReLU
#0x03 反向传播（Backprop）
#为了反向传播误差，我们所要做的就是调用loss.backward()。不过，你需要清除现有的梯度，否则梯度就会累积到已有的梯度上。
#现在我们应该调用loss.backward()，并在反向之前和之后查看conv1的偏差梯度。
net.zero_grad() # zeroes the gradient buffers of all parameters
print('conv1.bias.grad before backward')
print(net.conv1.bias.grad) #conv1和bias可以换成其它函数（relu，linear），bias可以换成weight
loss.backward()
print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)
#0x04 更新权重
#在实践中使用的最简单的更新规则是随机梯度下降法（Stochastic Gradient Descent，SGD）：
#weight = weight - learning_rate * gradient
#我们可以使用简单的python代码实现这一点：
learning_rate = 0.01
for f in net.parameters():
f.data.sub_(f.grad.data * learning_rate) #Variable里面的值调用使用data？
#然而，当你使用神经网络时，你可能想使用各种不同的更新规则，如SGD、Nesterov-SGD、Adam、RMSProp等等。
#为了实现这一点，我们构建了一个小的工具包torch.optim，它实现了所有这些方法。使用它非常简单：
import torch.optim as optim
# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)
# in your training loop:
optimizer.zero_grad() # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # Does the update
print("***********************************************************")
print("loss after optimizer:",loss)#经过优化以后打印损失观察一下
print("params[1] after optimizer:",params[1])#经过优化以后打印conv1的偏倚bias和上面未经优化的偏倚bias可以进行对比
#优化以后如何再进一步优化，优化到什么程度算是ok了？
Net(
(conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(fc1): Linear(in_features=400, out_features=120, bias=True)
(fc2): Linear(in_features=120, out_features=84, bias=True)
(fc3): Linear(in_features=84, out_features=10, bias=True)
)
***********************************************************
***********************************************************
10
Parameter containing:
tensor([ 0.1703, -0.1637, 0.1829, -0.1471, -0.0758, -0.0585],
requires_grad=True)
***********************************************************
tensor([[ 0.1154, 0.0158, 0.0087, -0.1210, -0.0249, 0.0537, -0.0099, 0.0766,
-0.0059, -0.0395]], grad_fn=<AddmmBackward>)
***********************************************************
loss: tensor(38.5074, grad_fn=<MseLossBackward>)
<MseLossBackward object at 0x00000000096CCD68>
<AddmmBackward object at 0x00000000096CCF28>
<AccumulateGrad object at 0x00000000096CCD68>
conv1.bias.grad before backward
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([-0.0713, 0.1072, 0.1073, -0.0711, 0.0175, -0.1034])
***********************************************************
loss after optimizer: tensor(37.9959, grad_fn=<MseLossBackward>)
params[1] after optimizer: Parameter containing:
tensor([ 0.1711, -0.1658, 0.1826, -0.1456, -0.0762, -0.0577],
requires_grad=True)
#【PyTorch深度学习60分钟快速入门 】Part4：训练一个分类器
#太棒啦！到目前为止，你已经了解了如何定义神经网络、计算损失，以及更新网络权重。不过，现在你可能会思考以下几个方面：
#0x01 训练数据集 https://www.cnblogs.com/leejack/p/8388776.html
#通常，当你需要处理图像、文本、音频或视频数据时，你可以使用标准的python包将数据加载到numpy数组中。然后你可以将该数组转换成一个torch.*Tensor。
#对于图像，Pillow、OpenCV这些包将有所帮助。
#对于音频，可以使用scipy和librosa包。
#对于文本，无论是基于原始的Python还是Cython的加载，或者NLTK和SpaCy都将有所帮助。
#具体对于图像来说，我们已经创建了一个名为torchvision的包，它为像Imagenet、CIFAR10、MNIST等公共数据集提供了数据加载器，并为图像提供了数据转换器，即torchvision.datasets和torch.utils.data.DataLoader。
#这提供了极大的便利，避免了编写样板代码。
#对于本教程，我们将使用CIFAR10数据集。它包含以下10个分类：飞机、汽车、鸟、猫、鹿、狗、青蛙、马、轮船和卡车。
#CIFAR-10数据集中的图像大小为3x32x32，即大小为32x32像素的3通道彩色图像。
#0x02 训练一个图像分类器，我们将按顺序执行以下步骤：
#使用torchvision加载并归一化CIFAR10训练和测试数据集，定义一个卷积神经网络，定义一个损失函数，利用训练数据来训练网络，利用测试数据来测试网络
#1. 加载和归一化CIFAR10，使用torchvision可以很容易地加载CIFAR10。
import torch
import torchvision #需要在pytorch官网上安装带cuda版本的torch，否则这一步会报错，cuda可能需要事先安装
import torchvision.transforms as transforms
#torchvision数据集的输出结果为像素值在[0,1]范围内的PILImage图像。我们将它们转换成标准化范围[-1,1]的张量：
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
#为了增添一些乐趣，我们来展示一些训练图片：
import matplotlib.pyplot as plt
import numpy as np
# functions to show an image
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()
# show images
imshow(torchvision.utils.make_grid(images))
#print (labels)
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
#2. 定义一个卷积神经网络
#从前面“神经网络”一节中拷贝神经网络并对其进行修改，使它接受3通道的图像（而不是原先定义的单通道图像）。
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
#3. 定义损失函数和优化器
#让我们用一个分类交叉熵的损失函数，以及带动量的SGD：
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
#4. 训练网络
#这里正是事情开始变得有趣的地方。我们只需循环遍历我们的数据迭代器，并将输入量输入到网络并进行优化：
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs
inputs, labels = data
# wrap them in Variable
inputs, labels = Variable(inputs), Variable(labels)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item() ##需要将原代码中的loss.data[0] 改为loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
#5. 在测试数据上测试网络
#我们已经利用训练数据集对网络训练了2次。但是，我们需要检查网络是否已经学到了什么。
#我们将通过预测神经网络输出的类标签来检查它，并根据实际情况对其进行检查。如果预测是正确的，那么我们将该样本添加到正确的预测列表中。
#OK！第一步，让我们展示测试集中的一个图像，以便于我们熟悉它。
dataiter = iter(testloader)
images, labels = dataiter.next()
# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
#现在让我们看看神经网络认为上面例子中的对象是什么：
outputs = net(Variable(images))
#输出结果是10个类的能量值。如果一个类的能量值越高，那么网络就越可能认为图像是该特定类。所以，我们来获取最高能量值对应的索引：
_, predicted = torch.max(outputs.data, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))
#结果看起来相当不错。下面，我们看一下该网络在整个数据集上的表现。
correct = 0
total = 0
for data in testloader:
images, labels = data
outputs = net(Variable(images))
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum()
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))
#结果看起来比随机概率要好，随机概率为10%的准确率（随机从10个类中挑选一个类）。看起来似乎该网络学到了一些东西。
#下面，我们看一下到底是哪些类别表现的很好，哪些类别表现的不好：
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
for data in testloader:
images, labels = data
outputs = net(Variable(images))
_, predicted = torch.max(outputs.data, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i]
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))
#Ok，下一步我们将学习如何在GPU上运行神经网络。
#0x03 在GPU上训练
#将神经网络转移到GPU上，就像将一个张量转移到GPU上一样。这将递归地遍历所有模块，并将它们的参数和缓冲器转换为CUDA张量：
##net.cuda()
#记住，你还必须将每一步的输入和目标都发送到GPU上：
##inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
#为什么与CPU相比，我没有看到速度的明显提升？那是因为你的网络实在是太小了。
#练习： 尝试增加网络的宽度（第一个nn.Conv2d的参数2，以及第二个nn.Conv2d的参数1，它们必须为同一个数字），然后看下速度提升效果。
#实现的目标：以更高的角度理解PyTorch的Tensor库和神经网络,训练一个小型的神经网络来对图像进行分类
#0x04 在多个GPU上训练
#如果你想使用所有GPU来得到速度更大的提升，可以阅读下一节“数据并行性”。
#0x05 扩展阅读
#Train neural nets to play video games
#Train a state-of-the-art ResNet network on imagenet
#Train a face generator using Generative Adversarial Networks
#Train a word-level language model using Recurrent LSTM networks
#More examples
#More tutorials
#Discuss PyTorch on the Forums
#Chat with other users on Slack
Files already downloaded and verified Files already downloaded and verified ship truck deer deer [1, 2000] loss: 2.232 [1, 4000] loss: 1.889 [1, 6000] loss: 1.703 [1, 8000] loss: 1.608 [1, 10000] loss: 1.536 [1, 12000] loss: 1.443 [2, 2000] loss: 1.409 [2, 4000] loss: 1.370 [2, 6000] loss: 1.339 [2, 8000] loss: 1.327 [2, 10000] loss: 1.309 [2, 12000] loss: 1.291 Finished Training GroundTruth: cat ship ship plane Predicted: cat ship ship plane Accuracy of the network on the 10000 test images: 54 % Accuracy of plane : 0 % Accuracy of car : 0 % Accuracy of bird : 0 % Accuracy of cat : 0 % Accuracy of deer : 0 % Accuracy of dog : 0 % Accuracy of frog : 0 % Accuracy of horse : 0 % Accuracy of ship : 1 % Accuracy of truck : 0 %
#【PyTorch深度学习60分钟快速入门 】Part5：数据并行化
#在本节中，我们将学习如何利用DataParallel使用多个GPU。在PyTorch中使用多个GPU非常容易，你可以使用下面代码将模型放在GPU上：
#model.gpu()
#然后，你可以将所有张量拷贝到GPU上：
#mytensor = my_tensor.gpu()
#请注意，仅仅调用my_tensor.gpu()并不会将张量拷贝到GPU上，你需要将它指派给一个新的张量，然后在GPU上使用这个新张量。
#在多个GPU上执行你的前向和后向传播是一件很自然的事情。然而，PyTorch默认情况下只会使用一个GPU。
#不过，通过利用DataParallel使你的模型并行地运行，这样你就能很容易地将操作运行在多个GPU上：
#model = nn.DataParallel(model)
#这正是本节的核心。下面，我们将更详细地分析该技术。
#0x01 导入和参数,下面，导入PyTorch模块并定义相关参数：
import torch
import torch.nn as nn
from torch.autograd import Variable
from torch.utils.data import Dataset, DataLoader
# Parameters and DataLoaders
input_size = 5
output_size = 2
batch_size = 30
data_size = 100
#0x02 虚拟数据集,创建一个虚拟的（随机的）数据集。你只需要实现__getitem__方法：
class RandomDataset(Dataset):
def __init__(self, size, length):
self.len = length
self.data = torch.randn(length, size)
def __getitem__(self, index):
return self.data[index]
def __len__(self):
return self.len
rand_loader = DataLoader(dataset=RandomDataset(input_size, 100),batch_size=batch_size, shuffle=True)
#0x03 简单模型
#在该demo中，我们的模型只会接受一个输入，并进行一个线性操作，然后给出输出结果。
#然而，你可以在任何模型（CNN、RNN、Capsule Net等等）上使用DataParallel。
#在模型内部我们添加了一个打印语句，以监控输入和输出的张量大小。请注意在rank 0批次时打印的内容：
class Model(nn.Module):
# Our model
def __init__(self, input_size, output_size):
super(Model, self).__init__()
self.fc = nn.Linear(input_size, output_size)
def forward(self, input):
output = self.fc(input)
print(" In Model: input size", input.size(),
"output size", output.size())
return output
#0x04 创建模型和数据并行化
#这是本教程的核心部分。首先，我们需要创建一个模型实例，并检查我们是否拥有多个GPU。
#如果拥有多个GPU，那么可以使用nn.DataParallel来封装我们的模型。然后，利用model.gpu()将模型放到GPU上：
model = Model(input_size, output_size)
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
# dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs
model = nn.DataParallel(model)
if torch.cuda.is_available():
model.cuda()
#0x05 运行模型,现在，我们可以查看输入与输出张量的大小：
for data in rand_loader:
if torch.cuda.is_available():
input_var = Variable(data.cuda())
else:
input_var = Variable(data)
output = model(input_var)
print("Outside: input size", input_var.size(),
"output_size", output.size())
#0x06 结果
#当我们将输入和输出都以30个作为批量大小时，正常情况下该模型会得到30并输出30。但如果你有多个GPU，那么你将会得到下面的结果：
#2个GPU,如果你有2个GPU，你将看到：
# on 2 GPUs
"""
Let's use 2 GPUs!
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2])
In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2])
Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])
"""
#3个GPU,如果你有3个GPU，你将看到：
"""
Let's use 3 GPUs!
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])
"""
#8个GPU,如果你有8个GPU，你将看到：
"""
Let's use 8 GPUs!
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])
"""
#0x07 总结
#DataParallel会自动分割数据，并将作业顺序发送给多个GPU上的多个模型。
#在每个模型完成它们的作业之后，DataParallel会收集并合并结果，然后再返回给你。
In Model: input size torch.Size([30, 5]) output size torch.Size([30, 2]) Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2]) In Model: input size torch.Size([30, 5]) output size torch.Size([30, 2]) Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2]) In Model: input size torch.Size([30, 5]) output size torch.Size([30, 2]) Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2]) In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2]) Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])
来源：https://www.cnblogs.com/brave-sailor/p/11588733.html