Torch入门笔记(更新)

PyTorch是基于PYTHON的科学计算包，为了使用GPU来替代NUMPY，灵活性和速度较好。

Tensor

张量类似与numpy的ndarrays，不同在与张量可以使用GPU来加快计算。很舒服，torch和numpy基本很相似，函数的运用名字也是。

rand是平均分布,即等概率分布,等概率产生0-1范围内的数 randn是标准正态分布,均值为0,标准差为1
torch的操作大全
https://pytorch.org/docs/stable/torch.html

x = torch.Tensor(5, 3)
print(x)
x1 = torch.rand(5, 3)
print(x1)
print(x1.size())  # torch.Size实际上是一个元组，所以它支持元组相同的操作。

x2 = torch.rand(5, 3)
print(x2)
print(x2.size())

print(x1+x2)  # add和+是一样的。逐点相加
print(torch.add(x1, x2))

tensor([[-4.8115e-09,  8.7301e-43, -4.8115e-09],
        [ 8.7301e-43, -4.8115e-09,  8.7301e-43],
        [-4.8115e-09,  8.7301e-43, -4.8115e-09],
        [ 8.7301e-43, -4.8115e-09,  8.7301e-43],
        [-4.8115e-09,  8.7301e-43, -4.8115e-09]])
tensor([[0.4675, 0.4238, 0.3129],
        [0.7232, 0.8212, 0.4657],
        [0.1884, 0.6845, 0.0129],
        [0.1611, 0.2918, 0.3728],
        [0.7455, 0.0526, 0.9585]])
tensor([[0.2753, 0.7038, 0.1908],
        [0.2214, 0.3874, 0.1199],
        [0.5263, 0.2564, 0.2673],
        [0.6382, 0.8205, 0.8639],
        [0.2338, 0.0405, 0.1836]])
相加 tensor([[0.7428, 1.1276, 0.5037],
        [0.9446, 1.2086, 0.5855],
        [0.7147, 0.9409, 0.2802],
        [0.7993, 1.1123, 1.2366],
        [0.9792, 0.0931, 1.1421]])

numpy转torch!!!

import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(a)
a = torch.as_tensor(a)
print(a)

使用cuda函数将张量移动到GPU上

if torch.cuda.is_available():
    x1 = x1.cuda()
    x2 = x2.cuda()
    x1 + x2

Autograd：自动求导

自动求导是pytorch所有神经网络的核心。为张量上的所有操作提供了自动求导，是一个运行时定义的框架。反向传播是根据代码的运行来定义的，每次迭代可以不同。

Variable类

from torch.autograd import Variable
autograd.Variable是autograd包的核心类.它包装了张量(Tensor),支持几乎所有的张量上的操作.一旦你完成你的前向计算,可以通过.backward()方法来自动计算所有的梯度.

变量(Variable)和函数(Function)是相互联系的,并形成一个非循环图来构建一个完整的计算过程.每个变量有一个.grad_fn属性,它指向创建该变量的一个Function,用户自己创建的变量除外,它的grad_fn属性为None.

梯度

如果计算导数,可以在一个变量上调用**.backward().**如果一个Variable是一个标量(它只有一个元素值),你不必给该方法指定任何的参数,但是该Variable有多个值,你需要指定一个和该变量相同形状的的grad_output参数(查看API发现实际为gradients参数).

下面实现这个函数：

from torch.autograd import Variable
x = Variable(torch.ones(2, 2), requires_grad=True)

y = x + 2
z = y*y*3
out = z.mean()
print(z)
out.backward()
print(x.grad)

tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>)
out tensor(27., grad_fn=<MeanBackward0>)
tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])

神经网络

使用torch.nn包来构建

简单函数的介绍
#注意！pytorch的池化的stride默认是和卷积核的大小保持一致。
所以卷积输出的通道数也就是下一层的输入的通道数。
一维卷积的定义：

class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

self.conv1 = nn.Conv2d(1, 6, 3)  # 1输入的通道数， 6输出的通道数/也就是卷积核的数目， 3是卷积核的大小
self.conv2 = nn.Conv2d(6, 16, 3)
self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 16 * 6 * 6是将上一次得到的结果铺平成一维向量的形式，6*6是特征图的大小

训练过程：定义模型结构和参数——在数据集上迭代——通过神经网络处理输入——计算损失——梯度反向传播更改网络参数
weight = weight - learning_rate * gradient

！注意！

1. torch.nn 只支持小批量输入,整个torch.nn包都只支持小批量样本,而不支持单个样本
2. nn.Conv2d将接受一个4维的张量,每一维分别是sSamples * nChannels * Height * Width
   (样本数×通道数×高×宽).！！！注意通道数在第二维。
3. torch.squeeze() 这个函数主要对数据的维度进行压缩，去掉维数为1的的维度，默认是将a中所有为1的维度删掉。也可以通过dim指定位置，删掉指定位置的维数为1的维度。
   **torch.unsqueeze()**这个函数主要是对数据维度进行扩充。需要通过dim指定位置，给指定位置加上维数为1的维度。————类似 numpy的reshape，来给数据扩充维度。
4. view类似reshape，可以将tensor转成一维的，此时就像Flatten。或者可以转换成需要的形状。

举例：
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))

"""定义一个网络"""

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)


# 只需要定义forward函数，backward函数在使用autograd时自动创建。可以在forward中使用tensor的任何操作。
    def forward(self, x):
#         (2，2)窗口最大池化, F就是function
        x = F.max_pool1d(F.relu(self.conv1(x)), (2, 2))
# If size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

net = Net()
print(net)

LOSS函数

举例 mse

out = net(input)
target = Variable(torch.arange(1, 11))  # a dummy target, for example
criterion = nn.MSELoss()

loss = criterion(out, target)
print(loss)

调用loss.backward()反向传播误差，需要清楚已经存在的梯度，否则梯度将被累加到已存在的梯度上。