Pytorch_01 Tensor,Autograd，构建网络

Tensor

Tensor是PyTorch中的重要数据结构，可认为是一个高维数组，Tensor与numpy的ndarrays类似，但Tensor可以使用GPU加速

import torch as t#import A as B,给予A库一个B的别称，帮助记忆

#构建5*3矩阵，只是分配了空间，未初始化
x=t.Tensor(5,3)
print(x)
print(x.size())#查看x的形状
print(x.size()[0],x.size(1))#查看列的个数，两种写法等价
print(t.Size([4,5]))

#使用[0,1]均匀分布随机初始化二维数组
y=t.rand(5,3)
print(y)

#加法的三种写法
print(x+y)
print(t.add(x,y))
#指定加法结果的输出目标未result
result=t.Tensor(5,3)#预先分配空间
t.add(x,y,out=result)#输入到result
print(result)

函数名后面带下划线_的函数会修改Tensor本身。例如，x.add_(y)和x.t_()会改变x，但x.add(y)和x.t()会返回一个新的Tensor，且x不变

Tenor与numpt极为相似，Tensor和numpy的数组见的互操作非常容易且快速，Tensor不支持的操作可先转为numpy数组处理，之后再转回Tensor。

a=t.ones(5)
print(a)

b=a.numpy()
print(b)

c=np.ones(5)
d=t.from_numpy(c)#Numpy->Tensor
print(c)
print(d)

#Tensor和Numpy共享内存，其中一个改变另一个也会随之改变
d.add_(1)
print(c)
print(d)

Tensor可通过.cuda方法转为GPU的Tensor，从而享受GPU的加速

x=t.rand(3,5)
y=t.ones(3,5)

print(t.cuda.is_available())

if t.cuda.is_available():
    x=x.cuda()
    y=y.cuda()
    z=x+y
print(z)

Autograd：自动微分

深度学习的算法本质是通过反向传播求导数，Autograd模块实现了此功能，在Tensor上的所有操作，Autograd都能为他们自动提供微分，避免手动计算导数。

autograd.Variable是Autograd的核心类，它封装了Tensor，并支持几乎所有Tensor的操作。Tensor在被封装为Variable之后，可以调用它的.backward实现反向传播，计算所有梯度。

Variable主要包含三个属性。

data：保存Variable所包含的Tensor。

grad：保存data对应的梯度，grad也是个Variable，而不是Tensor，它和data的形状一样。

grad_fn:指向一个Function对象，这个Function用来反向传播计算输入的梯度。

注意：grad在反向传播过程中是累加的，意味着每次运行反向传播，梯度都回累加之前的梯度，所以反向传播前需把梯度清零。

from torch.autograd import Variable

#使用Tensor新建一个Variable

x=Variable(t.ones(2,2),requires_grad=True)
print(x)

y=x.sum()
print(y)
print(y.grad_fn)

y.backward()#反向传播，计算梯度
print(x.grad)

y.backward()
print(x.grad)

#梯度清零
x.grad.data.zero_()
print(x.grad)

Variable和Tensor有几乎一致的接口，在实际使用中可以无缝切换

x=Variable(t.ones(4,5))

y=t.cos(x)#返回元素的余弦

print(y)

x_tensor_cos=t.cos(x.data)

print(x_tensor_cos)

pytorch构建神经网络

torch.nn是专门为神经网络设计的模块化接口。nn构建于Autograd之上，可用来定义和运行神经网络。nn.Module是nn中最重要的类，包含网络各层定义及forward方法，调用forward(input)方法，可返回前向传播的结果。

1.定义网络：

　　定义网络时，需要继承nn.Module,并实现它的forward方法，把网络中具有可学习参数的层放在构造函数__init__()中。如果某一层不具有可学习参数，则既可以放在构造函数中，也可不放。

import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        # nn.Module子类的函数必须在构造函数中执行父类的构造函数
        # 下式等价于nn.Module.__init__(self)
        super().__init__()
        # 卷积层'1'表示输入图片为单通道，'6'表示输出通道数
        # '5'表示卷积核为5*5
　　　　　#卷积核为2维
        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):
        #卷积->激活->池化
        x=F.max_pool2d(F.relu(self.conv1(x)),(2,2))
        x=F.max_pool2d(F.relu(self.conv1(x)),2)
        #reshpe,'-1'表示自适应
        x=x.view(x.size()[0],-1)
        x=F.relu(self.fc1(x))
        x=F.relu(self.fc2(x))
        x=self.fc3
        return x

net=Net()
print(net)

只要在nn.module的子类中定义了forward函数，backward函数就会被自动实现(利用Autograd)。在forward函数中可使用任何Variable支持的函数，还可以使用if、for循环、print、log等Python语法

网络的可学习参数通过net.parameters()返回，net.named_parameters可同时返回可学习的参数及名称。