pytorch-1.10简介

什么是pytorch

PyTorch是一个开源机器学习Python库，用于深度学习实现，如计算机视觉和自然语言处理。它是由Facebook的AI Research Lab(Fair)于2016年开发的，自数据科学和ML领域以来已采用，并且具有oop支持和动态计算图等具有很大的功能。

除了构建深度神经网络之外，由于其GPU加速，Pytorch也非常适合复杂的数学计算。此功能允许Pytorch使用计算机的GPU来大量加速计算。

这种独特的功能和Pytorch的无与伦比的简单的组合使其成为最受欢迎的深度学习库之一。

为什么要使用pytorch

在Pytorch之前，开发人员使用高级微积分来查找反向传播错误和节点加权之间的关系。更深的神经网络呼吁越来越复杂的 *** 作，限制机器学习的规模和易在性。

现在，可以使用MLlib自动完成所有的微积分!ML库可以在几秒钟内计算任何大小或形状网络，允许更多开发人员构建更大和更好的网络。

Pytorch通过表现类似于标准Python来进一步进行构建。可以使用现有的Python知识来快速开始启动。此外，可以使用Pycharm调试器对Pytorch进行调试。

pytorch与tensorflow.

Pytorch和Tensorflow之间的主要区别是简单和性能之间的权衡：Pytorch更容易学习(特别是对于Python程序员)，而Tensorflow具有学习曲线，但执行更好并且更广泛地使用。

• 人气：Tensorflow是行业专业人士和研究人员的当前使用工具，因为它比Pytorch较早发布了1年。然而，Pytorch用户的增长速度比Tensorflow更快。
• 数据并行性：Pytorch自动声明性数据并行性，它会自动将数据处理的工作量分布在不同的GPU上以加速性能。Tensorflow有并行性，但它要求您手动分配工作，这通常是耗时的。
• 动态与静态图：Pytorch默认情况下具有动态图，可立即响应新数据。Tensorflow使用TensoRFlow Fold， 对动态图的支持有限，但主要使用静态图。
• 集成：由于其通过TorchServe密切连接，Pytorch适用于AWS上的项目。Tensorflow与Google Cloud相结合，并且由于其使用SWIFT API而非常适合移动应用程序。
• 可视化：Tensorflow拥有更强大的可视化工具，并提供更精细的图形设置控制。Pytorch的Visdom可视化工具或类似Matplotlib的其他标准绘图库并不像Tensorflow那样完全齐全，但它们更容易学习。

pytorch基础知识 1. 张量

Pytorch Tensors是所有高级 *** 作的基础的多维阵列变量。与标准数字类型不同，可以分配张量以使用CPU或GPU加速 *** 作。它们与N维数量数量类似，甚至可以仅在单行中转换为Numpy数组。

张量有十种CPU和GPU类型： 

修改默认类型

pytorch使用FloatTensor作为张量的默认类型，但可以使用下面这个命令来修改

torch.set_default_tensor_type(t) 

初始化张量

import torch 
# initializing tensors 
a = torch.tensor(2) 
b = torch.tensor(1) 

简单的数学运算

# addition 
print(a+b) 
# subtraction 
print(b-a) 
# multiplication 
print(a*b) 
# division 
print(a/b) 

使用GPU的CUDA处理张量

if torch.cuda.is_available(): 
    xx = x.cuda() 
    yy = y.cuda() 

# 或者
torch.zeros([2, 4], dtype=torch.int32)
cuda0 = torch.device('cuda:0')
torch.ones([2, 4], dtype=torch.float64, device=cuda0)

得到单个值

# 只能对单个值 *** 作，如果是多个值会报错
x = torch.tensor([[1]])
x.item()

x = torch.tensor(2.5)
x.item()

记录反向传播值

x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
out = x.pow(2).sum()
out.backward()
x.grad

2. 神经网络

神经网络是连接和加权数据节点的层。Pytorch使用Torch.nn包定义神经网络，其中包含一组模块来表示网络的每层。

每个模块接收输入张量并计算输出张量，一起组合创建网络。Torch.nn封装还定义了用于训练神经网络的损失函数。建立神经网络的步骤是：

• 模型架构：创建神经网络层，设置参数，建立权重和偏置。
• 正向传播：使用参数计算预测的输出。通过比较预测和实际输出来测量误差。
• 反向传播：在找到错误后，在神经网络的参数方面采用错误函数的导数。反向传播允许更新权重参数。
• 迭代优化：使用优化器通过使用梯度下降来使用迭代更新参数的优化器来最小化错误。

这是Pytorch中神经网络的示例：

import torch 
import torch.nn as nn 
import torch.nn.functional as F 
class Net(nn.Module): 
    def __init__(self): 
        super(Net, self).__init__() 
        # 1 input image channel, 6 output channels, 3x3 square convolution 
        # kernel 
        self.conv1 = nn.Conv2d(1, 6, 3) 
        self.conv2 = nn.Conv2d(6, 16, 3) 
        # an affine operation: y = Wx + b 
        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension 
        self.fc2 = nn.Linear(120, 84) 
        self.fc3 = nn.Linear(84, 10) 
    def forward(self, x): 
        # Max pooling over a (2, 2) window 
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) 
        # If the size is a square you can only specify a single number 
        x = F.max_pool2d(F.relu(self.conv2(x)), 2) 
        xx = 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:]  # all dimensions except the batch dimension 
        num_features = 1 
        for s in size: 
            num_features *= s 
        return num_features 
net = Net() 
print(net) 

nn.Module标记这是一个神经网络，然后我们用2个Conv2D层执行2D卷积，以及3个线性层执行线性变换。接下来，定义前向传播方法。不需要定义向后传播方法，因为Pytorch默认包括反向传播backward()功能。

3. Autograd

Autograd是一个用于计算神经网络 *** 作所必需的导数的Pytorch包。这些导数称为梯度。在前向传播期间，Autograd在梯度的张量上记录所有 *** 作，并创建一个非循环图，以找到张量和所有 *** 作之间的关系。此 *** 作集合称为自动微分。

该图的叶子是输入张量，根部是输出张量。Autograd通过跟踪从根到叶子节点并将每个梯度使用链式规则相乘来计算梯度。在计算梯度之后，导数的值被自动填充到张量的grad属性中。

import torch 
# pytorch tensor 
x=torch.tensor(3.5,requires_grad=True)
# y is defined as a function of x 
y = (x-1)*(x-2)*(x-3)
# work out gradients 
y.backward() 

# 查看x的grad属性
x.grad

默认情况下，requires_grad设置为FALSE，PyTorch不会跟踪梯度值。在初始化期间指定requires_grad为TRUE将对该特定张量进行梯度跟踪。

对y=(x-1)*(x-2)*(x-3)自动计算梯度dy / dx，即3x ^ 2 - 12x + 11，得到该梯度的数值，并将其放置在张量x的grad属性中，同时根据x为3.5的实际值计算出梯度值为3*(3.5*3.5) - 12 *(3.5)+ 11 = 5.75，与上面的x.grad中的值一致。

梯度值默认累加，如果未重置，则可能会影响结果。使用model.zero_grad()在每次梯度计算后，将图重置为零。

4. 优化器

优化器在模型中更新权重和偏置以减少损失误差。所有Pytorch优化器都包含在Torch.optim包中，通过传递参数列表来构建抽象优化方案。

例如，可以实现公共优化算法，SGD(随机梯度下降)，对数据进行平滑。

import torch.optim as optim 
params = torch.tensor([1.0, 0.0], requires_grad=True) 
learning_rate = 1e-3 
## SGD 
optimoptimizer = optim.SGD([params], lr=learning_rate) 

更新模型后，使用优化器.step()来重新计算模型。使用优化器，需要使用循环手动更新模型参数：

for params in model.parameters():  
       params -= params.grad * learning_rate 

总的来说，优化器通过优化数据权重来改变模型权重而无需重新构建模型来节省大量时间。

5. pytorch计算图

为了更好地了解Pytorch和神经网络，可以使用计算图来练习。这些图本质上是一种简化版本的神经网络，用于有一系列 *** 作，用于了解系统的输出如何受输入的影响。即输入x用于找到y，然后用y找到输出z。

想象一下，Y和Z计算如下：

• y = x ^ 2
• z = 2Y + 3

但是，我们对输出Z如何使用Input X进行更加感兴趣，因此需要执行一些微积分：

• dz / dx =(dz / dy)*(dy / dx)
• dz / dx = 2.2x
• dz / dx = 4x

将输入x = 3.5带入公式，得到z = 14。

知道如何根据其他张量定义每个张量，可以知道这些张量在图中如何连接。

使用图，可以看到每个张量如何受到任何其他张量的变化的影响。这些张量的关系是梯度，用于在训练期间更新神经网络：

import torch 
# set up simple graph relating x, y and z 
x = torch.tensor(3.5, requires_grad=True) 
y = x*x 
z = 2*y + 3 
print("x: ", x) 
print("y = x*x: ", y) 
print("z= 2*y + 3: ", z) 
# work out gradients 
z.backward() 
print("Working out gradients dz/dx") 
# what is gradient at x = 3.5 
print("Gradient at x = 3.5: ", x.grad) 

这发现Z = 14，与手算得到的值一致。

多路径计算图

上面是一个具有单一关系的计算图，尝试一个更复杂的例子。首先，定义两个张量，a和b，以用作输入，确保设置requires_grad= TRUE，可以将梯度保存到最开始的输入端。

import torch 
# set up simple graph relating x, y and z 
a = torch.tensor(3.0, requires_grad=True) 
b = torch.tensor(2.0, requires_grad=True) 

接下来，设置输入和神经网络的每层之间的关系，x，y和z。请注意，z是更加x和y得到的，而x和y使用输入值a和b进行定义的。

import torch 
# set up simple graph relating x, y and z 
a = torch.tensor(3.0, requires_grad=True) 
b = torch.tensor(2.0, requires_grad=True) 
x = 2*a + 3*b 
y = 5*a*a + 3*b*b*b 
z = 2*x + 3*y 

这构建了一个关系链，Pytorch可以了解数据之间的所有关系。现在可以通过从z到a的路径来计算梯度dz / da。有两条路径，一个通过x和另一条通过y。应该将两条路径的表达式进行相加，因为a到z的两条路径都对z的值有贡献。

第一路径通过x得到2 * 2，第二条路径通过y得到3 * 10a。因此，z随着4 + 30a的速率变化。如果a是2，则dz / da为4 + 30 * 2 = 64。可以通过z向后传播后，查看a的梯度值来进行确认。

import torch 
# set up simple graph relating x, y and z 
a = torch.tensor(2.0, requires_grad=True) 
b = torch.tensor(1.0, requires_grad=True) 
x = 2*a + 3*b 
y = 5*a*a + 3*b*b*b 
z = 2*x + 3*y 
# work out gradients 
z.backward() 
print("Working out gradient dz/da") 
# what is gradient at a = 2.0 
print("Gradient at a=2.0:", a.grad)