Pytorch入门(笔记)

最新推荐文章于 2024-05-10 17:35:06 发布

Cherry_csc

最新推荐文章于 2024-05-10 17:35:06 发布

阅读量108

点赞数

文章标签： pytorch 笔记人工智能

本文链接：https://blog.csdn.net/Cherry_csc/article/details/134083603

版权

学习Pytorch笔记，完整notebook代码链接pytorch-book/chapter02-quickstart/chapter2: PyTorch快速入门.ipynb at master · chenyuntc/pytorch-book (github.com)

Tensor

加法三种写法：

import torch as t
x = t.rand(5, 3)
y = t.rand(5, 3)
x + y # 第一种
t.add(x, y)  # 第二种
result = t.Tensor(5, 3)  #预先分配空间
t.add(x, y, out=result)  #第三种

print('最初y')
print(y)

print('第一种加法，y的结果')
y.add(x) # 普通加法，不改变y的内容
print(y)

print('第二种加法，y的结果')
y.add_(x) # inplace 加法，y变了
print(y)

最初y
tensor([[0.4018, 0.0661, 0.1942],
        [0.9261, 0.1729, 0.3974],
        [0.3494, 0.5539, 0.0621],
        [0.5915, 0.7290, 0.3228],
        [0.9858, 0.6441, 0.4047]])
第一种加法，y的结果
tensor([[0.4018, 0.0661, 0.1942],
        [0.9261, 0.1729, 0.3974],
        [0.3494, 0.5539, 0.0621],
        [0.5915, 0.7290, 0.3228],
        [0.9858, 0.6441, 0.4047]])
第二种加法，y的结果
tensor([[1.3989, 0.5617, 0.9267],
        [1.4302, 0.4502, 0.5107],
        [0.5054, 1.4337, 0.4496],
        [1.4012, 1.5774, 0.9716],
        [1.5367, 1.2256, 0.5118]])

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

numpy 和tensor对象可以共享内存

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

b.add_(1)
a, b

[2. 2. 2. 2. 2.]
tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

.item获取元素数值，tensor[idx]获取的还是一个0-dim tensor

scalar = b[0]
scalar.item() # 使用scalar.item()能从中取出python对象的数值

数据拷贝&共享内存

t.tensor()或者tensor.clone()总是会进行数据拷贝，新tensor和原来的数据不再共享内存。所以如果你想共享内存的话，建议使用torch.from_numpy()或者tensor.detach()来新建一个tensor, 二者共享内存。

tensor = t.tensor([3,4]) # 新建一个包含 3，4 两个元素的tensor
old_tensor = tensor
new_tensor = old_tensor.clone()
new_tensor[0] = 1111
old_tensor, new_tensor

out：(tensor([3, 4]), tensor([1111, 4]))

new_tensor = old_tensor.detach()
new_tensor[0] = 1111
old_tensor, new_tensor

out: (tensor([1111, 4]), tensor([1111, 4]))

tensor

out: tensor([1111, 4])

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

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

x

Out:

tensor([[1., 1.],
        [1., 1.]], requires_grad=True)

y = x.sum()
y

Out:

tensor(4., grad_fn=<SumBackward0>)

y.grad_fn

Out:

<SumBackward0 at 0x7f63e55b7810>

y.backward() # 反向传播,计算梯度

# y = x.sum() = (x[0][0] + x[0][1] + x[1][0] + x[1][1])
# 每个值的梯度都为1
x.grad

Out:

tensor([[1., 1.],
        [1., 1.]])

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

# 以下划线结束的函数是inplace操作，会修改自身的值，就像add_
x.grad.data.zero_()

神经网络

Autograd实现了反向传播功能，但是直接用来写深度学习的代码在很多情况下还是稍显复杂，torch.nn是专门为神经网络设计的模块化接口。nn构建于 Autograd之上，可用来定义和运行神经网络。nn.Module是nn中最重要的类，可把它看成是一个网络的封装，包含网络各层定义以及forward方法，调用forward(input)方法，可返回前向传播的结果。下面就以最早的卷积神经网络：LeNet为例，来看看如何用nn.Module实现。LeNet的网络结构如图2-7所示。

这是一个基础的前向传播(feed-forward)网络: 接收输入，经过层层传递运算，得到输出。

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 函数中可使用任何tensor支持的函数，还可以使用if、for循环、print、log等Python语法，写法和标准的Python写法一致。

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

params = list(net.parameters())
print(len(params))
# print(params)
print(params[0].size())

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])

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

损失函数

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

output = net(input)
target = t.arange(0, 10).view(1, 10).float()
criterion = nn.MSELoss()
loss = criterion(output, target)
loss

output

tensor(28.9949, grad_fn=<MseLossBackward0>)

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

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d  
      -> view -> linear -> relu -> linear -> relu -> linear 
      -> MSELoss
      -> loss

output = net(input)
target = t.arange(0, 10).view(1, 10).float()
criterion = nn.MSELoss()
loss = criterion(output, target)
loss

Out:tensor(28.9949, grad_fn=<MseLossBackward0>)

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

net.zero_grad()
print(net.conv1.bias.grad)
loss.backward()
print(net.conv1.bias.grad)

None

tensor([-0.0857, -0.0101, 0.1339, 0.0129, 0.0696, 0.0432])

Optimizer

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