深度学习框架PyTorch-- 第二章PyTorch快速入门

 """

    
 Tensor是PyTorch中重要的数据结构，可认为是一个高维数组。它可以是一个数(标量),一维数组(向量),二维数组(矩阵)以及更高维的数组。
    
 Tensor和Numpy的ndarrays类似,但Tensor可以使用GPU进行加速。Tensor的使用和Numpy及Matlab的接口十分类似,下面通过几个例子来看看Tensor的基本使用.
    
 """
    
  
    
 #torch的版本
    
 from __future__ import print_function
    
 import torch as t
    
 print(t.__version__)
    
  
    
 #构建5*3矩阵
    
 x=t.Tensor(5,3)
    
 print(x)
    
 #查看x的形状
    
 print(x.size())
    
  
    
 #使用[0,1]均匀分布随机初始化二维数据
    
 x=t.rand(5,3)
    
 print(x)
    
 #查看列的个数,两种写法
    
 print(x.size(1))
    
 print(x.size()[1])
    
  
    
 #加法三种写法
    
 y=t.rand(5,3)
    
 res=x+y
    
 print(res)
    
 print(t.add(x,y))
    
 #加法的第三种写法:指定加法结果的输出目标为res
    
 res=t.Tensor(5,3)#余弦分配空间
    
 t.add(x,y,out=res)#输入到res
    
 print(res)
    
  
    
  
    
 #注意:函数名后面带下划线_的函数会修改Tensor本身。例如，x.add_(y)和x.t_()会改变x,但x.add(y)和x.t()返回一个Tensor,而x不变
    
 print('最初y')
    
 print(y)
    
  
    
 print('第一种加法,y的结果')
    
 y.add(x)#普通加法,不改变y的结果
    
 print(y)
    
  
    
 print('第二种加法,y的结果')
    
 y.add_(x)
    
 print(y)
    
  
    
 #Tensor的选取操作与Numpy类似
    
 print(x[:,1])#取x的第一列，列数从0开始
    
  
    
  
    
 #新建一个全1的Tensor
    
 a=t.ones(5)
    
 print(a)
    
  
    
 #Tensor-->Numpy
    
 b=a.numpy()
    
 print(b)
    
  
    
 #Tensor和Numpy对象共享内存,所以他们之间的转换很快，而且几乎不会消耗什么资源。但意味着如果一个变了，另一个也会随着改变。
    
 import numpy as np
    
 a=np.ones(5)
    
 b=t.from_numpy(a) #Numpy-->Tensor
    
 print(a)
    
 print(b)
    
  
    
 b.add_(1)#以'_'结尾的函数会修改自身
    
 print(a)
    
 print(b)#Tensor和Numpy共享内存,所以两者都会改变
    
  
    
 #如果你想取某一个元素的值,可以使用scalar.item。直接tensor[idx]得到的还是一个tensor:一个0-dim的tensor,一般称为scalar.
    
 scalar=b[0]
    
 print(scalar)
    
 print(scalar.size())#0-dim
    
 print(scalar.item())#使用scalar.item()能从中取出python对象的数值
    
  
    
 #注意和scalar的区别
    
 tensor=t.tensor([2])
    
 print(tensor,scalar)
    
 print(tensor.size(),scalar.size())
    
 print(tensor.item(),scalar.item())#只有一个元素的tensor也可以调用'tensor.item()'
    
  
    
 #此外在pytorch中还有一个和np.array()很类似的接口:torch.tensor,二者的使用十分类似
    
 tensor=t.tensor([3,4])#新建一个包含3,4两个元素的tensor
    
 scalar=t.tensor(3)
    
  
    
 old_tensor=tensor
    
 new_tensor=t.tensor(old_tensor)
    
 new_tensor[0]=1111
    
 print(old_tensor,new_tensor)
    
 #t.tensor()总会进行数据拷贝,新的tensor和原来的数据不再共享内存。所以如果你想共享内存的话，建议使用torch.from_numpy()或者tensor.detach()来新建一个tensor，二者共享内存
    
 new_tensor=old_tensor.detach()
    
 new_tensor[0]=1111
    
 print(old_tensor,new_tensor)
    
  
    
  
    
  
    
 """
    
 autograd:自动微分
    
 深度学习的算法本质上是通过反向传播求导数,而PyTorch的autograd模块则实现了此功能。
    
 在Tensor上的所有操作,autograd都能为它们自动提供微分，避免了自动计算导数的复杂过程.
    
 要想使用Tensor的autograd功能,只需要设置tensor.requries_grad=True
    
 """
    
  
    
 #为tensor设置requires_grad标识,代表着需要求导数
    
 #pytorch会自动调用autograd记录操作
    
 x=t.ones(2,2,requires_grad=True)#等价于x=t.ones(2,2) x.requires_grad=True
    
 print(x)
    
  
    
 y=x.sum()
    
 print(y)
    
  
    
 y.backward() #反向传播，计算梯度
    
 #y=x.sum()=(x[0][0]+x[0][1]+x[1][0]+x[1][1])
    
 #grad在反向传播过程中是累加的，这意味着每一次运行反向传播，梯度都会累加之前的梯度，所以反向传播之前需要把梯度清零
    
 print(x.grad)
    
  
    
 y.backward()
    
 print(x.grad)
    
  
    
 y.backward()
    
 print(x.grad)
    
  
    
 #以_结束的函数会修改自己的值
    
 print(x.grad.data.zero_())
    
  
    
 y.backward()
    
 print(x.grad)
    
  
    
  
    
 """
    
 神经网络
    
 Autograd实现了反向传播功能，但直接用来写深度学习的代码在很多情况下还是稍显复杂,
    
 torch.nn是专门为神经网络设计的模块化接口。nn构建于Autograd之上，可用来定义和运行神经网络。
    
 nn.Module是nn中最重要的类，可把它看成一个网络的封装，包含网络各层定义以及forward方法,调用forward(input)方法，可返回前向传播的结果。
    
 """
    
  
    
 "定义网络：在定义网络时，需要继承nn.Module,并实现它的forward方法，把网络中具有可学习参数的层放在构造函数__ini__中.如果某一层不具有可学习的参数，既可以放在构造函数中，也可以不放，但是建议不放在其中，而在forward中使用nn.functional代替"
    
 import torch.nn as nn
    
 import torch.nn.functional as F
    
  
    
 class Net(nn.Module):
    
     def __init__(self):
    
     # nn.Module子类的函数必须在构造函数中执行父类的构造函数
    
     #下式等价于nn.Module.__init__()
    
     super(Net,self).__init__()
    
  
    
     #卷积层 ’1‘表示输入图片为单通道，'6'表示输出通道数,'5'表示卷积核为5*5
    
     self.conv1=nn.Conv2d(1,6,5)
    
  
    
     #卷积层
    
     self.conv2=nn.Conv2d(6,16,5)
    
  
    
     #全连接层,y=Wx+b
    
     self.fc1=nn.Linear(16*5*5,120)
    
     self.fc2=nn.Linear(120,84)
    
     self.fc3=nn.Linear(84,10)
    
  
    
     def forward(self,x):
    
     #卷积-->激活-->池化
    
     # #最大池化 ,步幅是2*2
    
     x=F.max_pool2d(F.relu(self.conv1(x)),(2,2))
    
     ##大小为正方形，则只能指定一个数字
    
     x=F.max_pool2d(F.relu(self.conv2(x)),2)
    
     #reshape,'-1'表示自适应改变x的大小
    
     x=x.view(x.size()[0],-1)
    
     x=F.relu(self.fc1(x))
    
     x=F.relu(self.fc2(x))
    
     x=self.fc3(x)
    
     return x
    
 #只要在nn.Module的子类中定义了forward函数,backward函数就会自动被实现(利用autograd)
    
 net=Net()
    
 print(net)
    
  
    
 "网络的可学习参数通过net.parameters()返回，net.named_parameters可同时返回可学习的参数及名称"
    
 params=list(net.parameters())
    
 print(len(params))
    
  
    
 for name,parameters in net.named_parameters():
    
     print(name,':',parameters.size())
    
  
    
 input=t.randn(1,1,32,32)
    
 print(input)
    
 out=net(input)
    
 print(out.size())
    
  
    
 net.zero_grad()#所有参数的梯度清零
    
 out.backward(t.ones(1,10))#反向传播
    
  
    
  
    
 "损失函数：nn实现了神经网络中大多数的损失函数，例如nn.MSELoss用来计算均方误差，nn.CrossEntropyLoss用来计算交叉熵损失"
    
 output=net(input)
    
 target=t.arange(0,10).view(1,10).float()
    
 print(target.size())
    
 criterion=nn.MSELoss()
    
 loss=criterion(output,target)
    
 print(loss)
    
 """
    
 如果对loss进行反向传播溯源(使用gradfn属性)，可看到它的计算图如下：
    
   200. input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d  
    
       -> view -> linear -> relu -> linear -> relu -> linear 
    
       -> MSELoss
    
       -> loss
    
 当调用loss.backward()时，该图会动态生成并自动微分，
    
 也即会自动计算图中参数(Parameter)的导数。
    
 """
    
 #运行.backward,观察调用之前和调用之后的grad
    
 net.zero_grad()#把net中所有可学习的梯度清零
    
 print('反向传播之前conv1.bias的梯度')
    
 print(net.conv1.bias.grad)
    
 loss.backward()
    
 print('反向传播之后conv1.bias的梯度')
    
 print(net.conv1.bias.grad)
    
  
    
  
    
 "优化器:在反向传播计算完所有参数的梯度后,还需要使用优化方法来更新网络的权重和参数，例如随机梯度下降法(SGD)的更新策略"
    
 "weight=weight-learning_rate*gradient"
    
  
    
 #手动实现
    
 learning_rate=0.01
    
 for f in net.parameters():
    
     f.data.sub_(f.grad.data*learning_rate)#inplace减法
    
  
    
 "torch.optim中实现了深度学习中绝大多数的优化方法，例如RMSProp,Adam,SGD等，因此大多数不需要手动写上述代码"
    
 import torch.optim as optim
    
  
    
 #新建一个优化器，指定要调整的参数和学习率
    
 optimizer=optim.SGD(net.parameters(),lr=0.01)
    
  
    
 #在训练过程中先梯度清零(与net.zero_grad()效果一样)
    
 optimizer.zero_grad()
    
  
    
 #计算损失
    
 output=net(input)
    
 loss=criterion(output,target)
    
  
    
 #反向传播
    
 loss.backward()
    
  
    
 #更新参数
    
 optimizer.step()
    
  
    
 """
    
 数据加载与预处理
    
 在深度学习中数据加载及预处理是非常复杂繁琐的，但PyTorch提供了一些可极大简化和加快数据处理流程的工具。
    
 同时，对于常用的数据集，PyTorch也提供了封装好的接口供用户快速调用，这些数据集主要保存在torchvison中。
    
 torchvision实现了常用的图像数据加载功能，例如Imagenet、CIFAR10、MNIST等，以及常用的数据转换操作，这极大地方便了数据加载，并且代码具有可重用性。
    
 """
    
  
    
 """
    
 对CIFAR-10分类
    
 步骤如下:
    
 1.使用torchvision加载并预处理CIFAR-10数据集
    
 2.定义网络
    
 3.定义损失函数和优化器
    
 4.训练网络并更新网络参数
    
 5.测试网络
    
 """
    
  
    
 "数据集：http://www.cs.toronto.edu/~kriz/cifar.html"
    
 import torchvision as tv
    
 import torchvision.transforms as transforms
    
 from torchvision.transforms import ToPILImage
    
  
    
 show=ToPILImage() #可以把Tensor转成Image,方便可视化
    
  
    
 #第一次运行程序torchvision会自动下载CIFAR-10数据集,大约100M,需要花费一定时间
    
  
    
 #定义对数据的预处理
    
 transform=transforms.Compose([
    
     transforms.ToTensor(),#转为Tensor
    
     transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))#归一化
    
 ])
    
  
    
 #训练集
    
 trainset=tv.datasets.CIFAR10(
    
     root='.\data',
    
     train=True,
    
     download=True,
    
     transform=transform
    
 )
    
  
    
 trainloader=t.utils.data.DataLoader(
    
     trainset,
    
     batch_size=4,
    
     shuffle=True,
    
     num_workers=2
    
 )
    
  
    
  
    
 # 测试集
    
 testset=tv.datasets.CIFAR10(
    
     '.\data',
    
     train=False,
    
     download=True,
    
     transform=transform
    
 )
    
  
    
 testloader=t.utils.data.DataLoader(
    
     testset,
    
     batch_size=4,
    
     shuffle=False,
    
     num_workers=2
    
 )
    
  
    
 classes=('plane','car','bird','cat','deer','dog','frog','horse','ship','truck')
    
  
    
  
    
 """
    
 Dataloader是一个可迭代的对象，它将dataset返回的每一条数据拼接成一个batch，并提供多线程加速优化和数据打乱等操作。
    
 当程序对dataset的所有数据遍历完一遍之后，相应的对Dataloader也完成了一次迭代。
    
 """
    
  
    
 #定义网络
    
 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.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 = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
    
     x = F.max_pool2d(F.relu(self.conv2(x)), 2)
    
     x = x.view(x.size()[0], -1)
    
     x = F.relu(self.fc1(x))
    
     x = F.relu(self.fc2(x))
    
     x = self.fc3(x)
    
     return x
    
  
    
  
    
 net = Net()
    
 print(net)
    
  
    
 #定义损失函数和优化器(loss和optimizer)
    
 from torch import optim
    
 criterion=nn.CrossEntropyLoss()#交叉熵损失函数
    
 optimizer=optim.SGD(net.parameters(),lr=0.01,momentum=0.9)
    
  
    
 #训练网络
    
 #1.输入数据 2.前向传播+反向传播 3.更新参数
    
  
    
 if __name__ ==  '__main__':
    
     for epoch in range(2):
    
     running_loss=0.0
    
     for i,data in enumerate(trainloader,0):
    
          #输入数据
    
          inputs,labels=data
    
  
    
          #梯度清零
    
          optimizer.zero_grad()
    
  
    
          #forward+backward
    
          outputs=net(inputs)
    
          loss=criterion(outputs,labels)
    
          loss.backward()
    
  
    
          #更新参数
    
          optimizer.step()
    
  
    
          #打印log信息
    
          #loss是一个scalar,需要使用loss.item()来获取数值，不能用loss[0]
    
          running_loss+=loss.item()
    
          if i %2000==1999:#每2000个batch打印一下训练状态
    
              print('[%d, %5d] loss: %.3f' \
    
                    % (epoch + 1, i + 1, running_loss / 2000))
    
              running_loss = 0.0
    
     print('Finished Training')
    
  
    
     dataiter = iter(testloader) # 创建一个python迭代器，读入的是我们第一步里面就已经加载好的testloader
    
     images, labels = dataiter.next() # 一个batch返回4张图片
    
     print('实际的label: ', ' '.join(\
    
             '%08s'%classes[labels[j]] for j in range(4)))
    
     show(tv.utils.make_grid(images / 2 - 0.5)).resize((400,100))
    
     # python字符串格式化 ' '.join表示用空格来连接后面的字符串，
    
  
    
     "接着计算网络预测的label："
    
     # 计算图片在每个类别上的分数
    
     outputs = net(images)
    
     # 得分最高的那个类
    
     _, predicted = t.max(outputs.data, 1)
    
     # 这个 _ , predicted是python的一种常用的写法，表示后面的函数其实会返回两个值
    
     # 但是我们对第一个值不感兴趣，就写个_在那里，把它赋值给_就好，我们只关心第二个值predicted
    
     # 比如 _ ,a = 1,2 这中赋值语句在python中是可以通过的，你只关心后面的等式中的第二个位置的值是多少
    
  
    
     print('预测结果: ', ' '.join('%5s'\
    
             % classes[predicted[j]] for j in range(4)))
    
  
    
  
    
     correct = 0 # 预测正确的图片数
    
     total = 0 # 总共的图片数
    
  
    
  
    
     # 由于测试的时候不需要求导，可以暂时关闭autograd，提高速度，节约内存
    
     with t.no_grad():
    
     for data in testloader:
    
         images, labels = data
    
         outputs = net(images)
    
         _, predicted = t.max(outputs, 1)
    
         total += labels.size(0) # 更新测试图片的数量
    
         correct += (predicted == labels).sum()# 更新正确分类的图片的数量
    
  
    
  
    
     print('10000张测试集中的准确率为: %d %%' % (100 * correct / total))
    
  
    
  
    
     #来测试一下每一类的分类正确率
    
     class_correct = list(0. for i in range(10))  # 定义一个存储每类中测试正确的个数的 列表，初始化为0
    
     class_total = list(0. for i in range(10))  # 定义一个存储每类中测试总数的个数的 列表，初始化为0
    
     for data in testloader:  # 以一个batch为单位进行循环
    
     images, labels = data
    
     _, predicted = t.max(outputs.data, 1)
    
     c = (predicted == labels).squeeze()  #预测正确的数目
    
     for i in range(4):  # 因为每个batch都有4张图片，所以还需要一个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]))