PyTorch系列(一):1.快速入门

最新推荐文章于 2024-02-06 23:53:52 发布

Sophia$

最新推荐文章于 2024-02-06 23:53:52 发布

阅读量543

点赞数

分类专栏： PyTorch 文章标签： PyTorch Autograd

本文链接：https://blog.csdn.net/sophicchen/article/details/104014019

版权

PyTorch 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1. Tensor

from __future__ import print_function
import torch as t

x = t.Tensor(5,3) #构建5*3矩阵，只是分配了空间，未初始化
x = rand(5,3) #使用[0,1]均匀分布随机初始化二维数组
print(x.size()) #查看x的形状
# Print: torch.Size([5,3])

print(x.size()[0]) #查看x的行数
# torch.Size是tuple对象的子类，因此它支持tuple的所有操作，如x.size()[0]
print(x.size(1)) #查看x的列数

# 加法计算
y = t.rand(5,3)

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

# 加法计算
# 第一种加法，不改变y的内容
y.add(x) #普通加法
#第二种加法
y.add_(x) #inplace加法，y改变了

Tensor和numpy的数组间的互操作非常容易且快速。Tensor不支持的操作，可以先转为numpy数组处理，之后再转回Tensor。

a = t.ones(5)
# Out: tensor([1., 1., 1., 1., 1.])

b = a.numpy() # Tensor -> Numpy
# Out: array([1., 1., 1., 1., 1.], dtype=float32)


import numpy as np
a = np.ones(5)
b = t.from_numpy(a) # Numpy -> Tensor

Tensor和numpy对象共享内存，所以他们之间的转换很快，而且几乎不会消耗资源。这就意味着，如果其中一个变了，另外一个也会随之改变。

b.add_(1) #以_结束的函数会修改自身的值
print(a)
print(b) # Tensor和Numpy共享内存
# Out: [2. 2. 2. 2. 2.]
# Out: tensor([2., 2., 2., 2., 2.])

Tensor可通过.cuda方法转为GPU的Tensor，从而享受GPU带来的加速运算。

2.Autograd:自动微分

autograd.Variable是Autograd中的核心类，它简单封装了Tensor，并支持几乎所有Tensor操作。Tensor在被封装为Variable之后，可以调用它的.backward实现反向传播，自动计算所有梯度。Variable的数据结构如图所示。

Variable主要包含三个属性：

data：保存variable所包含的tensor
grad：保存data对应的梯度，grad也是variable，而不是tensor，它与data形状一致。
grad_fn：指向一个Function，记录tensor的操作历史，即它是什么操作的输出，用来构建计算图。如果某一个变量是由用户创建，则它为叶子节点，对应的grad_fn等于None。

Variable的构造函数需要传入tensor，同时有两个可选参数：

requires_grad (bool)：是否需要对该variable进行求导
volatile (bool)：意为”挥发“，设置为True，则构建在该variable之上的图都不会求导，专为推理阶段设计

Variable提供了大部分tensor支持的函数，但其不支持部分inplace函数，因这些函数会修改tensor自身，而在反向传播中，variable需要缓存原来的tensor来计算反向传播梯度。如果想要计算各个Variable的梯度，只需调用根节点variable的backward方法，autograd会自动沿着计算图反向传播，计算每一个叶子节点的梯度。

variable.backward(grad_variables=None, retain_graph=None, create_graph=None)主要有如下参数：

grad_variables：形状与variable一致，对于y.backward()，grad_variables相当于链式法则 $\frac{dz}{dx}=\frac{dz}{dy}\times \frac{dy}{dx}$ 中的 $\frac{dz}{dx}$ 。grad_variables也可以是tensor或序列。
retain_graph：反向传播需要缓存一些中间结果，反向传播之后，这些缓存就被清空，可通过指定这个参数不清空缓存，用来多次反向传播。
create_graph：对反向传播过程再次构建计算图，可通过backward of backward实现求高阶导数。

计算下面这个函数的导函数： $y=x^2 \cdot e^x$

它的导函数是： $\frac{dy}{dx}=2x \cdot e^x + x^2 \cdot e^x$

来看看autograd的计算结果与手动求导计算结果的误差。

def f(x): # 计算y
    y=x**2 * t.exp(x)
    return y
def gradf(x): #手动求导函数
    dx = 2*x*t.exp(x) + x**2*t.exp(x)
    return dx

x = Variable(t.randn(3,4), requires_grad = True)
y = f(x)
x
# Out: tensor([[ 0.2583, -0.7711,  0.4857,  0.6048],
#        [ 1.1318,  0.6371, -1.0199, -1.0027],
#        [-1.2990, -0.4510, -0.6040,  0.3999]], requires_grad=True)

y
# tensor([[0.0864, 0.2750, 0.3835, 0.6697],
#        [3.9729, 0.7677, 0.3751, 0.3689],
#        [0.4603, 0.1296, 0.1994, 0.2385]], grad_fn=<MulBackward0>)


y.backward(t.ones(y.size())) #grad_variables形状与y一致
x.grad
# Out: tensor([[ 0.7552, -0.4383,  1.9624,  2.8844],
#        [10.9933,  3.1775, -0.3605, -0.3669],
#        [-0.2484, -0.4450, -0.4609,  1.4315]])
# autograd的计算结果与利用公式手动计算的结果一致
gradf(x)
# Out: tensor([[ 0.7552, -0.4383,  1.9624,  2.8844],
#        [10.9933,  3.1775, -0.3605, -0.3669],
#        [-0.2484, -0.4450, -0.4609,  1.4315]], grad_fn=<AddBackward0>)

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

x.grad.data.zero_()

3.神经网络

torch.nn是专门为神经网络设计的模块化接口。nn构建于Autograd之上，可用来定义和运行神经网络。nn.Module是nn中最重要的类，可以把它看作一个网络的封装，包含网络各层定义及forward方法，调用forward(input)方法，可返回前向传播的结果。我们以最早的卷积神经网络LeNet为例，来看看如何用nn.Module实现。LeNet的网络结构如图所示。

3.1定义网络

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

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(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):
        #卷积 -> 激活 -> 池化
        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.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)
# Out: 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)
#         )

只要在nn.Module的子类中定义了forward函数，backward函数就会被自动实现（利用Autograd）。在forward函数中可使用任何Variable支持的函数。

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

params = list(net.parameters())
print(len(params))
# Out: 10
for name, parameters in net.named_parameters():
    print(name,':',parameters.size())
# Out: conv1.weight : torch.Size([6, 1, 5, 5])
#      conv1.bias : torch.Size([6])
#      conv2.weight : torch.Size([16, 6, 5, 5])
#      conv2.bias : torch.Size([16])
#      fc1.weight : torch.Size([120, 400])
#      fc1.bias : torch.Size([120])
#      fc2.weight : torch.Size([84, 120])
#      fc2.bias : torch.Size([84])
#      fc3.weight : torch.Size([10, 84])
#      fc3.bias : torch.Size([10])

forward函数的输入和输出都是Variable，只有Variable才具有自动求导功能，Tensor是没有的，所以在输入时，需要把Tensor封装为Variable。

input = Variable(t.randn((1,1,32,32),dtype=t.float))
# input = t.rand((1, 1, 32, 32), dtype=t.float)

out = net(input)
out.size()
# Out: torch.Size([1,10])
net.zero_grad() #所有参数的梯度清零
# out.backward(Variable(t.ones(1,10))) #反向传播

注意：torch.nn只支持mini-batches,不支持一次只输入一个样本，即一次必须是一个batch。如果只想输入一个样本，则用input.unsqueeze(0)将batch_size设为1。例如，nn.Conv2d输入必须是4维的，形如nSamples*nChannels*Height*Width。可将nSample设为1，即1*nChannels*Height*Width.

# 比如，只有一张输入图片，也需要变成 N x C x H x W 的形式：    
input_image = torch.FloatTensor(1, 28, 28)   
input_image = input_image.unsqueeze(0)   # 1 x 1 x 28 x 28

3.2 损失函数

nn实现了神经网络中大多数的损失函数，例如nn.MSELoss用来计算均方误差，nn.CrossEntropyLoss用来计算交叉熵损失。

output = net(input)
# target = Variable(t.arange(0,10))
target = t.ones((1, 10), dtype=t.float)
criterion = nn.MSELoss()
loss = criterion(output, target)

如果对loss进行反向传播溯源(使用grad_fn属性)，可看到它的计算图如下：

当调用loss.backward()时，该图会动态生成并自动微分，也会自动计算途中参数(Parameters)导数。

#运行.backward,观察调用之前和调用之后的grad
net.zero_grad() #把net中所有可学习参数的梯度清零
print('反向传播之前conv1.bias的梯度')
print(net.conv1.bias.grad)
loss.backward()
print('反向传播之后conv1.bias的梯度')
print(net.conv1.bias.grad)
# Out: 反向传播之前conv1.bias的梯度
#      tensor([0., 0., 0., 0., 0., 0.])
#      反向传播之后conv1.bias的梯度
#      tensor([-0.0158, -0.0082,  0.0000,  0.0000, -0.0101, -0.0071])

3.3优化器

在反向传播计算完所有参数的梯度后，还需要使用优化方法更新网络的权重和参数。例如，随机梯度下降法（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()

3.4数据加载与预处理

torchvision实现了常用的图像数据加载功能，例如Imagenet，CIFAR10，MNIST等，以及常用的数据转换操作。

Sophia$

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
PyTorch系列(一):1.快速入门

1. Tensorfrom __future__ import print_functionimport torch as tx = t.Tensor(5,3) #构建5*3矩阵，只是分配了空间，未初始化x = rand(5,3) #使用[0,1]均匀分布随机初始化二维数组print(x.size()) #查看x的形状# Print: torch.Size([5,3])pri...
复制链接

扫一扫