网站建设中期怎么入账,郑州小程序定制,黄骅贴吧,wordpress 更换服务器文章目录 2.1 张量2.1.1 简介2.1.2 创建tensor2.1.3 张量的操作2.1.4 广播机制 2.2 自动求导Autograd简介2.2.1 梯度 2.3 并行计算简介2.3.1 为什么要做并行计算2.3.2 为什么需要CUDA2.3.3 常见的并行的方法#xff1a;网络结构分布到不同的设备中(Network partitioning)同一层… 文章目录 2.1 张量2.1.1 简介2.1.2 创建tensor2.1.3 张量的操作2.1.4 广播机制 2.2 自动求导Autograd简介2.2.1 梯度 2.3 并行计算简介2.3.1 为什么要做并行计算2.3.2 为什么需要CUDA2.3.3 常见的并行的方法网络结构分布到不同的设备中(Network partitioning)同一层的任务分布到不同数据中(Layer-wise partitioning)不同的数据分布到不同的设备中执行相同的任务(Data parallelism) 2.3.4 使用CUDA加速训练 2.1 张量
概述
张量的简介PyTorch如何创建张量PyTorch中张量的操作PyTorch中张量的广播机制
2.1.1 简介
几何代数中定义的张量是基于向量和矩阵的推广比如我们可以将标量视为零阶张量矢量可以视为一阶张量矩阵就是二阶张量。
张量维度代表含义0维张量代表的是标量数字1维张量代表的是向量2维张量代表的是矩阵3维张量时间序列数据 股价 文本数据 单张彩色图片(RGB)
张量是现代机器学习的基础。它的核心是一个数据容器多数情况下它包含数字有时候它也包含字符串但这种情况比较少。因此可以把它想象成一个数字的水桶。
这里有一些存储在各种类型张量的公用数据集类型
3维 时间序列4维 图像5维 视频
例子一个图像可以用三个字段表示
(width, height, channel) 3D但是在机器学习工作中我们经常要处理不止一张图片或一篇文档——我们要处理一个集合。我们可能有10,000张郁金香的图片这意味着我们将用到4D张量
(batch_size, width, height, channel) 4D2.1.2 创建tensor
随机初始化矩阵 我们可以通过torch.rand()的方法构造一个随机初始化的矩阵 import torch
x torch.rand(4, 3)
print(x)tensor([[0.7569, 0.4281, 0.4722],[0.9513, 0.5168, 0.1659],[0.4493, 0.2846, 0.4363],[0.5043, 0.9637, 0.1469]])全0矩阵的构建 我们可以通过torch.zeros()构造一个矩阵全为 0并且通过dtype设置数据类型为 long。除此以外我们还可以通过torch.zero_()和torch.zeros_like()将现有矩阵转换为全0矩阵.
import torch
x torch.zeros(4, 3, dtypetorch.long)
print(x)tensor([[0, 0, 0],[0, 0, 0],[0, 0, 0],[0, 0, 0]])张量的构建 我们可以通过torch.tensor()直接使用数据构造一个张量
import torch
x torch.tensor([5.5, 3])
print(x)tensor([5.5000, 3.0000])基于已经存在的 tensor创建一个 tensor
x x.new_ones(4, 3, dtypetorch.double)
# 创建一个新的全1矩阵tensor返回的tensor默认具有相同的torch.dtype和torch.device
# 也可以像之前的写法 x torch.ones(4, 3, dtypetorch.double)
print(x)
x torch.randn_like(x, dtypetorch.float)
# 重置数据类型
print(x)
# 结果会有一样的size
# 获取它的维度信息
print(x.size())
print(x.shape)tensor([[1., 1., 1.],[1., 1., 1.],[1., 1., 1.],[1., 1., 1.]], dtypetorch.float64)
tensor([[ 2.7311, -0.0720, 0.2497],[-2.3141, 0.0666, -0.5934],[ 1.5253, 1.0336, 1.3859],[ 1.3806, -0.6965, -1.2255]])
torch.Size([4, 3])
torch.Size([4, 3])返回的torch.Size其实是一个tuple⽀持所有tuple的操作。我们可以使用索引操作取得张量的长、宽等数据维度。
常见的构造Tensor的方法
函数功能Tensor(sizes)基础构造函数tensor(data)类似于np.arrayones(sizes)全1zeros(sizes)全0eye(sizes)对角为1其余为0arange(s,e,step)从s到e步长为steplinspace(s,e,steps)从s到e均匀分成step份rand/randn(sizes)rand是[0,1)均匀分布randn是服从N(01)的正态分布normal(mean,std)正态分布(均值为mean标准差是std)randperm(m)随机排列
2.1.3 张量的操作
在接下来的内容中我们将介绍几种常见的张量的操作方法
加法操作
import torch
# 方式1
y torch.rand(4, 3)
print(x y)# 方式2
print(torch.add(x, y))# 方式3 in-place原值修改
y.add_(x)
print(y)tensor([[ 2.8977, 0.6581, 0.5856],[-1.3604, 0.1656, -0.0823],[ 2.1387, 1.7959, 1.5275],[ 2.2427, -0.3100, -0.4826]])
tensor([[ 2.8977, 0.6581, 0.5856],[-1.3604, 0.1656, -0.0823],[ 2.1387, 1.7959, 1.5275],[ 2.2427, -0.3100, -0.4826]])
tensor([[ 2.8977, 0.6581, 0.5856],[-1.3604, 0.1656, -0.0823],[ 2.1387, 1.7959, 1.5275],[ 2.2427, -0.3100, -0.4826]])
索引操作(类似于numpy)
需要注意的是索引出来的结果与原数据共享内存修改一个另一个会跟着修改。如果不想修改可以考虑使用copy()等方法
import torch
x torch.rand(4,3)
# 取第二列
print(x[:, 1]) tensor([-0.0720, 0.0666, 1.0336, -0.6965])y x[0,:]
y 1
print(y)
print(x[0, :]) # 源tensor也被改了了tensor([3.7311, 0.9280, 1.2497])
tensor([3.7311, 0.9280, 1.2497])维度变换 张量的维度变换常见的方法有torch.view()和torch.reshape()下面我们将介绍torch.view()
x torch.randn(4, 4)
y x.view(16)
z x.view(-1, 8) # -1是指这一维的维数由其他维度决定
print(x.size(), y.size(), z.size())torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])注: torch.view() 返回的新tensor与源tensor共享内存(其实是同一个tensor)更改其中的一个另外一个也会跟着改变。(顾名思义view()仅仅是改变了对这个张量的观察角度)
x 1
print(x)
print(y) # 也加了了1tensor([[ 1.3019, 0.3762, 1.2397, 1.3998],[ 0.6891, 1.3651, 1.1891, -0.6744],[ 0.3490, 1.8377, 1.6456, 0.8403],[-0.8259, 2.5454, 1.2474, 0.7884]])
tensor([ 1.3019, 0.3762, 1.2397, 1.3998, 0.6891, 1.3651, 1.1891, -0.6744,0.3490, 1.8377, 1.6456, 0.8403, -0.8259, 2.5454, 1.2474, 0.7884])取值操作 如果我们有一个元素 tensor 我们可以使用 .item() 来获得这个 value而不获得其他性质
import torch
x torch.randn(1)
print(type(x))
print(type(x.item()))class torch.Tensor
class floatPyTorch中的 Tensor 支持超过一百种操作包括转置、索引、切片、数学运算、线性代数、随机数等等具体使用方法可参考官方文档。
2.1.4 广播机制
当对两个形状不同的 Tensor 按元素运算时可能会触发广播(broadcasting)机制先适当复制元素使这两个 Tensor 形状相同后再按元素运算。
x torch.arange(1, 3).view(1, 2)
print(x)
y torch.arange(1, 4).view(3, 1)
print(y)
print(x y)tensor([[1, 2]])
tensor([[1],[2],[3]])
tensor([[2, 3],[3, 4],[4, 5]])由于x和y分别是1行2列和3行1列的矩阵如果要计算xy那么x中第一行的2个元素被广播 (复制)到了第二行和第三行⽽y中第⼀列的3个元素被广播(复制)到了第二列。如此就可以对2个3行2列的矩阵按元素相加。
2.2 自动求导
PyTorch 中所有神经网络的核心是 autograd 包。autograd包为张量上的所有操作提供了自动求导机制。它是一个在运行时定义 ( define-by-run 的框架这意味着反向传播是根据代码如何运行来决定的并且每次迭代可以是不同的。
autograd的求导机制梯度的反向传播
Autograd简介
torch.Tensor 是这个包的核心类。如果设置它的属性 .requires_grad 为 True那么它将会追踪对于该张量的所有操作。当完成计算后可以通过调用 .backward()来自动计算所有的梯度。这个张量的所有梯度将会自动累加到.grad属性。
注意在 y.backward() 时如果 y 是标量则不需要为 backward() 传入任何参数否则需要传入一个与 y 同形的Tensor。
要阻止一个张量被跟踪历史可以调用.detach()方法将其与计算历史分离并阻止它未来的计算记录被跟踪。为了防止跟踪历史记录(和使用内存可以将代码块包装在 with torch.no_grad(): 中。在评估模型时特别有用因为模型可能具有 requires_grad True 的可训练的参数但是我们不需要在此过程中对他们进行梯度计算。
还有一个类对于autograd的实现非常重要Function。Tensor 和 Function 互相连接生成了一个无环图 (acyclic graph)它编码了完整的计算历史。每个张量都有一个.grad_fn属性该属性引用了创建 Tensor 自身的Function(除非这个张量是用户手动创建的即这个张量的grad_fn是 None )。
from __future__ import print_function
import torch
x torch.randn(3,3,requires_gradTrue)
print(x.grad_fn)None如果需要计算导数可以在 Tensor 上调用 .backward()。如果 Tensor 是一个标量(即它包含一个元素的数据则不需要为 backward() 指定任何参数但是如果它有更多的元素则需要指定一个gradient参数该参数是形状匹配的张量。
创建一个张量并设置requires_gradTrue用来追踪其计算历史
x torch.ones(2, 2, requires_gradTrue)
print(x)tensor([[1., 1.],[1., 1.]], requires_gradTrue)对这个张量做一次运算
y x**2
print(y)tensor([[1., 1.],[1., 1.]], grad_fnPowBackward0)y是计算的结果所以它有grad_fn属性。
print(y.grad_fn)PowBackward0 object at 0x000001CB45988C70对 y 进行更多操作
z y * y * 3
out z.mean()print(z, out)tensor([[3., 3.],[3., 3.]], grad_fnMulBackward0) tensor(3., grad_fnMeanBackward0).requires_grad_(...) 原地改变了现有张量的requires_grad标志。如果没有指定的话默认输入的这个标志是 False。
a torch.randn(2, 2) # 缺失情况下默认 requires_grad False
a ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b (a * a).sum()
print(b.grad_fn)False
True
SumBackward0 object at 0x000001CB4A19FB502.2.1 梯度
现在开始进行反向传播因为 out 是一个标量因此out.backward()和 out.backward(torch.tensor(1.)) 等价。
out.backward()输出导数 d(out)/dx
print(x.grad)tensor([[3., 3.],[3., 3.]])数学上若有向量函数 y ⃗ f ( x ⃗ ) \vec{y}f(\vec{x}) y f(x )那么 y ⃗ \vec{y} y 关于 x ⃗ \vec{x} x 的梯度就是一个雅可比矩阵 J ( ∂ y 1 ∂ x 1 ⋯ ∂ y 1 ∂ x n ⋮ ⋱ ⋮ ∂ y m ∂ x 1 ⋯ ∂ y m ∂ x n ) J\left(\begin{array}{ccc}\frac{\partial y_{1}}{\partial x_{1}} \cdots \frac{\partial y_{1}}{\partial x_{n}} \\ \vdots \ddots \vdots \\ \frac{\partial y_{m}}{\partial x_{1}} \cdots \frac{\partial y_{m}}{\partial x_{n}}\end{array}\right) J ∂x1∂y1⋮∂x1∂ym⋯⋱⋯∂xn∂y1⋮∂xn∂ym 而 torch.autograd 这个包就是用来计算一些雅可比矩阵的乘积的。例如如果 v v v 是一个标量函数 l g ( y ⃗ ) l g(\vec{y}) lg(y ) 的梯度 v ( ∂ l ∂ y 1 ⋯ ∂ l ∂ y m ) v\left(\begin{array}{lll}\frac{\partial l}{\partial y_{1}} \cdots \frac{\partial l}{\partial y_{m}}\end{array}\right) v(∂y1∂l⋯∂ym∂l) 由链式法则我们可以得到 v J ( ∂ l ∂ y 1 ⋯ ∂ l ∂ y m ) ( ∂ y 1 ∂ x 1 ⋯ ∂ y 1 ∂ x n ⋮ ⋱ ⋮ ∂ y m ∂ x 1 ⋯ ∂ y m ∂ x n ) ( ∂ l ∂ x 1 ⋯ ∂ l ∂ x n ) v J\left(\begin{array}{lll}\frac{\partial l}{\partial y_{1}} \cdots \frac{\partial l}{\partial y_{m}}\end{array}\right)\left(\begin{array}{ccc}\frac{\partial y_{1}}{\partial x_{1}} \cdots \frac{\partial y_{1}}{\partial x_{n}} \\ \vdots \ddots \vdots \\ \frac{\partial y_{m}}{\partial x_{1}} \cdots \frac{\partial y_{m}}{\partial x_{n}}\end{array}\right)\left(\begin{array}{lll}\frac{\partial l}{\partial x_{1}} \cdots \frac{\partial l}{\partial x_{n}}\end{array}\right) vJ(∂y1∂l⋯∂ym∂l) ∂x1∂y1⋮∂x1∂ym⋯⋱⋯∂xn∂y1⋮∂xn∂ym (∂x1∂l⋯∂xn∂l)
注意grad在反向传播过程中是累加的(accumulated)这意味着每一次运行反向传播梯度都会累加之前的梯度所以一般在反向传播之前需把梯度清零。
# 再来反向传播⼀一次注意grad是累加的
out2 x.sum()
out2.backward()
print(x.grad)out3 x.sum()
x.grad.data.zero_()
out3.backward()
print(x.grad)tensor([[4., 4.],[4., 4.]])
tensor([[1., 1.],[1., 1.]])现在我们来看一个雅可比向量积的例子
x torch.randn(3, requires_gradTrue)
print(x)y x * 2
i 0
while y.data.norm() 1000:y y * 2i i 1
print(y)
print(i)tensor([-0.9332, 1.9616, 0.1739], requires_gradTrue)
tensor([-477.7843, 1004.3264, 89.0424], grad_fnMulBackward0)
8在这种情况下y 不再是标量。torch.autograd 不能直接计算完整的雅可比矩阵但是如果我们只想要雅可比向量积只需将这个向量作为参数传给 backward
v torch.tensor([0.1, 1.0, 0.0001], dtypetorch.float)
y.backward(v)print(x.grad)tensor([5.1200e01, 5.1200e02, 5.1200e-02])也可以通过将代码块包装在 with torch.no_grad(): 中来阻止 autograd 跟踪设置了.requires_gradTrue的张量的历史记录。
print(x.requires_grad)
print((x ** 2).requires_grad)with torch.no_grad():print((x ** 2).requires_grad)True
True
False如果我们想要修改 tensor 的数值但是又不希望被 autograd 记录(即不会影响反向传播) 那么我们可以对 tensor.data 进行操作。
x torch.ones(1,requires_gradTrue)print(x.data) # 还是一个tensor
print(x.data.requires_grad) # 但是已经是独立于计算图之外y 2 * x
x.data * 100 # 只改变了值不会记录在计算图所以不会影响梯度传播y.backward()
print(x) # 更改data的值也会影响tensor的值
print(x.grad)tensor([1.])
False
tensor([100.], requires_gradTrue)
tensor([2.])2.3 并行计算简介
在利用PyTorch做深度学习的过程中可能会遇到数据量较大无法在单块GPU上完成或者需要提升计算速度的场景这时就需要用到并行计算。
并行计算的简介CUDA简介并行计算的三种实现方式使用CUDA加速训练
2.3.1 为什么要做并行计算
深度学习的发展离不开算力的发展GPU的出现让我们的模型可以训练的更快更好。所以如何充分利用GPU的性能来提高我们模型学习的效果这一技能是我们必须要学习的。这一节我们主要讲的就是PyTorch的并行计算。PyTorch可以在编写完模型之后让多个GPU来参与训练减少训练时间。
2.3.2 为什么需要CUDA
CUDA是我们使用GPU的提供商——NVIDIA提供的GPU并行计算框架。对于GPU本身的编程使用的是CUDA语言来实现的。但是在我们使用PyTorch编写深度学习代码时使用的CUDA又是另一个意思。在PyTorch使用 CUDA表示要开始要求我们的模型或者数据开始使用GPU了。
在编写程序中当我们使用了 .cuda() 时其功能是让我们的模型或者数据从CPU迁移到GPU(0)当中通过GPU开始计算。
注
我们使用GPU时使用的是.cuda()而不是使用.gpu()。这是因为当前GPU的编程接口采用CUDA但是市面上的GPU并不是都支持CUDA只有部分NVIDIA的GPU才支持AMD的GPU编程接口采用的是OpenCL在现阶段PyTorch并不支持。数据在GPU和CPU之间进行传递时会比较耗时我们应当尽量避免数据的切换。GPU运算很快但是在使用简单的操作时我们应该尽量使用CPU去完成。当我们的服务器上有多个GPU我们应该指明我们使用的GPU是哪一块如果我们不设置的话tensor.cuda()方法会默认将tensor保存到第一块GPU上等价于tensor.cuda(0)这将会导致爆出out of memory的错误。我们可以通过以下两种方式继续设置。 #设置在文件最开始部分
import os
os.environ[CUDA_VISIBLE_DEVICE] 2 # 设置默认的显卡CUDA_VISBLE_DEVICE0,1 python train.py # 使用01两块GPU2.3.3 常见的并行的方法
网络结构分布到不同的设备中(Network partitioning)
在刚开始做模型并行的时候这个方案使用的比较多。其中主要的思路是将一个模型的各个部分拆分然后将不同的部分放入到GPU来做不同任务的计算。其架构如下 这里遇到的问题就是不同模型组件在不同的GPU上时GPU之间的传输就很重要对于GPU之间的通信是一个考验。但是GPU的通信在这种密集任务中很难办到所以这个方式慢慢淡出了视野。
同一层的任务分布到不同数据中(Layer-wise partitioning)
第二种方式就是同一层的模型做一个拆分让不同的GPU去训练同一层模型的部分任务。其架构如下 这样可以保证在不同组件之间传输的问题但是在我们需要大量的训练同步任务加重的情况下会出现和第一种方式一样的问题。
不同的数据分布到不同的设备中执行相同的任务(Data parallelism)
第三种方式有点不一样它的逻辑是我不再拆分模型我训练的时候模型都是一整个模型。但是我将输入的数据拆分。所谓的拆分数据就是同一个模型在不同GPU中训练一部分数据然后再分别计算一部分数据之后只需要将输出的数据做一个汇总然后再反传。其架构如下 这种方式可以解决之前模式遇到的通讯问题。现在的主流方式是数据并行的方式(Data parallelism)
2.3.4 使用CUDA加速训练
在PyTorch框架下CUDA的使用变得非常简单我们只需要显式的将数据和模型通过.cuda()方法转移到GPU上就可加速我们的训练在此处我们仅讨论单卡的情况下后续我们会介绍多卡训练的使用方法。
model Net()
model.cuda() # 模型显示转移到CUDA上for image,label in dataloader:# 图像和标签显示转移到CUDA上image image.cuda() label label.cuda()
