十二、pytorch的基础知识
1、快捷命令
2、Tensor
Tensor是PyTorch中重要的数据结构,可认为是一个高维数组。它可以是一个数(标量)、一维数组(向量)、二维数组(矩阵)以及更高维的数组。Tensor和Numpy的ndarrays类似,但Tensor可以使用GPU进行加速。
Tensor的基本使用:
from __future__ import print_function
import torch as t
(1)创建Tensor
构建 5x3 矩阵,只是分配了空间,未初始化
x = t.Tensor(5, 3) x = t.Tensor([[1,2],[3,4]]) ##tensor([[1., 2.], ## [3., 4.]])
(2)使用[0,1]均匀分布随机初始化二维数组
x = t.rand(5, 3) x ##tensor([[0.1595, 0.0289, 0.6098], ## [0.3763, 0.2346, 0.9171], ## [0.9731, 0.4014, 0.6734], ## [0.2359, 0.8480, 0.5956], ## [0.1340, 0.5178, 0.5605]])
(3)torch.Size 是tuple对象(元组)的子类,因此它支持tuple的所有操作,如x.size()[0]
print(x.size()) # 查看x的形状 x.size()[1], x.size(1) # 查看列的个数, 两种写法等价 ## torch.Size([5, 3]) (3,3)
(4)Tensor的运算
y = t.rand(5, 3) # 加法的第一种写法 x + y # 加法的第二种写法 t.add(x, y) # 加法的第三种写法:指定加法结果的输出目标为result result = t.Tensor(5, 3) # 预先分配空间 t.add(x, y, out=result) # 输入到result result
-
- 注意,函数名后面带下划线**_** 的函数会修改Tensor本身。例如,x.add_(y)和x.t_()会改变 x,但x.add(y)和x.t()返回一个新的Tensor, 而x不变。
(5)Tensor的选取操作与Numpy类似,Tensor和Numpy的数组之间的互操作非常容易且快速。对于Tensor不支持的操作,可以先转为Numpy数组处理,之后再转回Tensor。
import numpy as np a = np.ones(5) b = t.from_numpy(a) # Numpy->Tensor b.add_(1) # 以`_`结尾的函数会修改自身 print(a) print(b) # Tensor和Numpy共享内存 # [2. 2. 2. 2. 2.] # tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
-
- Tensor和numpy对象共享内存,所以他们之间的转换很快,而且几乎不会消耗什么资源。但这也意味着,如果其中一个变了,另外一个也会随之改变。
(6)如果你想获取某一个元素的值,可以使用`scalar.item`。 直接`tensor[idx]`得到的还是一个tensor: 一个0-dim(零维,表示单个数值) 的tensor,一般称为scalar.
import torch # 创建一个 1D Tensor tensor = torch.tensor([10, 20, 30, 40, 50]) # 使用索引获取元素 index = 2 scalar_tensor = tensor[index] # 这里返回的是一个 0 维的 Tensor print("获取的标量 Tensor:", scalar_tensor) # 输出: tensor(30) # 使用 item() 方法获取 Python 原生数值 value = scalar_tensor.item() print("获取的具体值:", value) # 输出: 30
(7)需要注意的是,t.tensor()
或者tensor.clone()
总是会进行数据拷贝,新tensor和原来的数据不再共享内存。所以如果你想共享内存的话,建议使用torch.from_numpy()
或者tensor.detach()
来新建一个tensor, 二者共享内存。
tensor = t.tensor([3,4]) # 新建一个包含 3,4 两个元素的tensor scalar = t.tensor(3) old_tensor = tensor new_tensor = old_tensor.clone() new_tensor[0] = 1111 old_tensor, new_tensor # (tensor([3, 4]), tensor([1111, 4])) new_tensor = old_tensor.detach() new_tensor[0] = 1111 old_tensor, new_tensor # (tensor([1111, 4]), tensor([1111, 4]))
(8)Tensor可通过.cuda
方法转为GPU的Tensor,从而享受GPU带来的加速运算。
# 在不支持CUDA的机器下,下一步还是在CPU上运行 device = t.device("cuda:0" if t.cuda.is_available() else "cpu") x = x.to(device) y = y.to(x.device) # 确保x和y在同一设备上 z = x+y
3、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 y = x.sum() # tensor(4., grad_fn=<SumBackward0>) y.grad_fn # <SumBackward0 at 0x7f63e55b7810> 查看 y 的梯度函数,可以看出 y 是通过 SumBackward0 计算得到的。 y.backward() # 反向传播,计算梯度,由于 y 是通过 x 计算得出的,PyTorch 会自动计算出 x 的梯度。 # y = x.sum() = (x[0][0] + x[0][1] + x[1][0] + x[1][1]) # 因为 y 是通过对 x 的所有元素求和得到的,因此每个 x 元素对 y 的贡献都是 1,梯度值为 1。 x.grad # tensor([[1., 1.], # [1., 1.]]) y.backward() x.grad # tensor([[2., 2.], # [2., 2.]]) ## 注意:grad在反向传播过程中是累加的(accumulated),这意味着每一次运行反向传播,梯度都会累加之前的梯度,所以反向传播之前需把梯度清零。 # 以下划线结束的函数是inplace操作,会修改自身的值,就像add_ x.grad.data.zero_() # tensor([[0., 0.], # [0., 0.]]) y.backward() x.grad # tensor([[1., 1.], # [1., 1.]])
4、神经网络
Autograd实现了反向传播功能,但是直接用来写深度学习的代码在很多情况下还是稍显复杂,torch.nn是专门为神经网络设计的模块化接口。nn构建于 Autograd之上,可用来定义和运行神经网络。nn.Module是nn中最重要的类,可把它看成是一个网络的封装,包含网络各层定义以及forward方法,调用forward(input)方法,可返回前向传播的结果。
下面以LeNet为例,来看看如何用nn.Module
实现。LeNet 这个网络虽然很小,但是它包含了深度学习的基本模块:卷积层,池化层,全链接层。是其他深度学习模型的基础,
(1)定义网络
定义网络时,需要继承nn.Module
,并实现它的forward方法,把网络中具有可学习参数的层放在构造函数__init__
中。如果某一层(如ReLU)不具有可学习的参数,则既可以放在构造函数中,也可以不放,但建议不放在其中,而在forward中使用nn.functional
代替。
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) # 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
可同时返回可学习的参数及名称。
for name,parameters in net.named_parameters(): print(name,':',parameters.size()) # 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函数的输入和输出都是Tensor。
# 生成一个随机张量(input),其尺寸为 (样本数,通道数,高度,宽度) input = t.randn(1, 1, 32, 32) # 将输入数据 input 传入网络 net,执行网络的前向传播,得到输出 out。 out = net(input) # 查看输出尺寸 out.size() # torch.Size([1, 10]) net.zero_grad() # 所有参数的梯度清零 out.backward(t.ones(1,10)) # 反向传播
需要注意的是,torch.nn只支持mini-batches,不支持一次只输入一个样本,即一次必须是一个batch。但如果只想输入一个样本,则用 input.unsqueeze(0)
将batch_size设为1。例如 nn.Conv2d
输入必须是4维的,形如nSamples x nChannels x Height x Width.可将nSample设为1,即1 x nChannels x Height x Width.
(2)损失函数
nn实现了神经网络中大多数的损失函数,例如nn.MSELoss用来计算均方误差,nn.CrossEntropyLoss用来计算交叉熵损失
output = net(input) # t.arange(0,10)创建一个从 0 到 9 的一维张量,.view(1, 10) 将一维张量的形状变为 (1, 10)的二维张量,表示一个样本的十个目标值。 target = t.arange(0,10).view(1,10).float() criterion = nn.MSELoss() loss = criterion(output, target) loss # loss是个标量scalar # tensor(28.6152, grad_fn=<MseLossBackward>)
如果对loss进行反向传播溯源(使用gradfn
属性),可看到它的计算图如下:
当调用loss.backward()
时,该图会动态生成并自动微分,也即会自动计算图中参数(Parameter)的导数。
# 运行.backward,观察调用之前和调用之后的grad net.zero_grad() # 把net中所有可学习参数的梯度清零 print('反向传播之前 conv1.bias的梯度') print(net.conv1.bias.grad) loss.backward() # PyTorch 会根据损失函数和模型的输出,利用链式法则自动计算每个参数的梯度。 print('反向传播之后 conv1.bias的梯度') print(net.conv1.bias.grad) # 反向传播之前 conv1.bias的梯度 # tensor([0., 0., 0., 0., 0., 0.]) # 反向传播之后 conv1.bias的梯度 # tensor([ 0.1366, 0.0885, -0.0036, 0.1410, 0.0144, 0.0562])
(3)优化器
在反向传播计算完所有参数的梯度后,还需要使用优化方法来更新网络的权重和参数,例如随机梯度下降法(SGD)的更新策略如下:
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()
(4)数据加载与预处理
在深度学习中数据加载及预处理是非常复杂繁琐的,但PyTorch提供了一些可极大简化和加快数据处理流程的工具。同时,对于常用的数据集,PyTorch也提供了封装好的接口供用户快速调用,这些数据集主要保存在torchvison中。
torchvision
实现了常用的图像数据加载功能,例如Imagenet、CIFAR10、MNIST等,以及常用的数据转换操作,这极大地方便了数据加载,并且代码具有可重用性。
5、CIFAR-10分类
下面我们来尝试实现对CIFAR-10数据集的分类,步骤如下:
1. 使用torchvision加载并预处理CIFAR-10数据集
2. 定义网络
3. 定义损失函数和优化器
4. 训练网络并更新网络参数
5. 测试网络
(1)CIFAR-10数据加载及预处理
CIFAR-10^3是一个常用的彩色图片数据集,它有10个类别: 'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'。每张图片都是3×32×32,也即3-通道彩色图片,分辨率为32×32。
import torchvision as tv import torchvision.transforms as transforms from torchvision.transforms import ToPILImage show = ToPILImage() # 可以把Tensor转成Image,方便可视化 # 第一次运行程序torchvision会自动下载CIFAR-10数据集, # 如果已经下载有CIFAR-10,可通过root参数指定 # 定义对数据的预处理 transform = transforms.Compose([ transforms.ToTensor(), # 转为Tensor transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), # 归一化 ]) # 训练集 trainset = tv.datasets.CIFAR10( root='/home/cy/tmp/data/', train=True, download=True, transform=transform) trainloader = t.utils.data.DataLoader( trainset, batch_size=4, shuffle=True, num_workers=2) # 测试集 testset = tv.datasets.CIFAR10( '/home/cy/tmp/data/', train=False, download=True, transform=transform) testloader = t.utils.data.DataLoader( testset, batch_size=4, shuffle=False, num_workers=2) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
其中Dataset对象是一个数据集,可以按下标访问,返回形如(data, label)的数据。
(data, label) = trainset[100] print(classes[label]) # (data + 1) / 2是为了还原被归一化的数据 show((data + 1) / 2).resize((100, 100))
Dataloader是一个可迭代的对象,它将dataset返回的每一条数据拼接成一个batch,并提供多线程加速优化和数据打乱等操作。当程序对dataset的所有数据遍历完一遍之后,相应的对Dataloader也完成了一次迭代。
dataiter = iter(trainloader) # 创建了一个迭代器 dataiter,可以用来逐步获取数据。 images, labels = dataiter.next() # 返回4张图片及标签 print(' '.join('%11s'%classes[labels[j]] for j in range(4))) show(tv.utils.make_grid((images+1)/2)).resize((400,100))
(2)定义网络
拷贝上面的LeNet网络,修改self.conv1第一个参数为3通道,因CIFAR-10是3通道彩图。
import torch.nn as nn import torch.nn.functional as F class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(3, 6, 5) self.conv2 = nn.Conv2d(6, 16, 5) 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) 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
(3)定义损失函数和优化器
from torch import optim criterion = nn.CrossEntropyLoss() # 交叉熵损失函数 optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
(4)训练网络
所有网络的训练流程都是类似的,不断地执行如下流程:
-
- 输入数据
- 前向传播和反向传播
- 更新参数
t.set_num_threads(8) # 设置了线程数量为8,这对于多线程处理数据和计算是有益的 for epoch in range(2): running_loss = 0.0 for i, data in enumerate(trainloader, 0): # 使用enumerate函数遍历trainloader中的每个mini-batch。 # 输入数据 inputs, labels = data # 梯度清零 optimizer.zero_grad() # forward + backward outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() # 更新参数 optimizer.step() # 打印log信息 # loss 是一个scalar,需要使用loss.item()来获取数值,不能使用loss[0] running_loss += loss.item() if i % 2000 == 1999: # 每2000个batch打印一下训练状态 print('[%d, %5d] loss: %.3f' \ % (epoch+1, i+1, running_loss / 2000)) running_loss = 0.0 print('Finished Training')
correct = 0 # 预测正确的图片数 total = 0 # 总共的图片数 # 由于测试的时候不需要求导,可以暂时关闭autograd,提高速度,节约内存 with t.no_grad(): for data in testloader: images, labels = data outputs = net(images) # 将神经网络输出的每个样本中最大值的索引存储在 predicted 变量中 _, predicted = t.max(outputs, 1) # _ 是一个占位符,通常用于接收不需要的返回值(在这里是最大值本身)。 total += labels.size(0) correct += (predicted == labels).sum() print('10000张测试集中的准确率为: %d %%' % (100 * correct / total))
(5)在GPU训练
就像之前把Tensor从CPU转到GPU一样,模型也可以类似地从CPU转到GPU。
device = t.device("cuda:0" if t.cuda.is_available() else "cpu") net.to(device) images = images.to(device) labels = labels.to(device) output = net(images) loss= criterion(output,labels) loss
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步