当前位置:   article > 正文

PyTorch与向量化计算_pytorch对每一个batch中的向量做运算

pytorch对每一个batch中的向量做运算

还是先认错啊  只为自己好加标签 自己看方便~~ 

向量化计算是一种特殊的并行计算方式。程序在同一时间内只执行一个操作,而并行计算可以在同一时间内执行多个操作。向量化计算是指对不同的数据执行同样的一个或一批指令,或者把指令应用到一个数组或向量上,从而将多次循环操作变成一次计算。

向量化操作可以极大地提高科学运算的效率。尽管Python本身使用简便,但是其中存在着许多低效的操作,例如for循环等。因此,在科学计算中应当极力避免使用Python原生的for循环,尽量使用向量化数值运算,下面举例说明:

In: import torch as t    # 定义for循环完成加法操作    def for_loop_add(x, y):        result = []        for i, j in zip(x, y):            result.append(i + j)        return t.tensor(result)
    x = t.zeros(100)    y = t.ones(100)    %timeit -n 100 for_loop_add(x, y)    %timeit -n 100 (x + y) # +是向量化计算Out:100 loops, best of 3: 786 µs per loop    100 loops, best of 32.57 µs per loop

从上面的例子中可以看出,for循环和向量化计算之间存在数百倍的速度差距,在实际使用中应该尽量调用内建函数(buildin-function)。这些函数底层由C/C++实现,在实现中使用了向量化计算的思想,通过底层优化实现了高效计算。在日常编程中应该养成向量化的编程习惯,避免对较大的Tensor进行逐元素的遍历操作,从而提高程序的运行效率。

这里主要从广播法则、高级索引两个方面介绍PyTorch中的向量化计算。 whaosoft aiot http://143ai.com

01

广播法则

广播法则(broadcast)是科学计算中经常使用的一个技巧,它在快速执行向量化计算的同时不会占用额外的内存/显存。NumPy中的广播法则定义如下。

  • 所有输入数组都与形状(shape)最大的数组看齐,形状不足的部分在前面加1补齐。

  • 两个数组要么在某一个维度的尺寸一致,要么其中一个数组在该维度的尺寸为1,否则不符合广播法则的要求。

  • 如果输入数组的某个维度的尺寸为1,那么计算时沿此维度复制扩充成目标的形状大小。

虽然PyTorch已经支持了自动广播法则,但是建议通过以下两种方式的组合手动实现广播法则,这样更加直观,也更不容易出错。

  • unsqueeze、view或者tensor[None] :为数据某一维度补1,实现第一个广播法则。

  • expand或者expand_as,重复数组,实现第三个广播法则;该操作不会复制整个数组,因此不会占用额外的空间。

注意:repeat可以实现与expand类似的功能,expand是在已经存在的Tensor上创建一个新的视图(view),repeat会将相同的数据复制多份,因此会占用额外的空间。

首先来看自动广播法则:

In: # 自动广播法则    # 第一步:a2维的,b3维的,所以先在较小的a前面补1个维度,    #       即:a.unsqueeze(0),a的形状变成(132),b的形状是(231),    # 第二步:ab在第一和第三个维度的形状不一样,同时其中一个为1    #       利用广播法则扩展,两个形状都变成了(232    a = t.ones(3, 2)    b = t.zeros(2, 3, 1)    (a + b).shapeOut:torch.Size([2, 3, 2])

再来看如何手动实现以上广播过程:​​​​​​​

In: # 手动广播法则,下面两行操作是等效的,推荐使用None的方法    # a.view(1, 3, 2).expand(2, 3, 2) + b.expand(2, 3, 2)    a[None,:,:].expand(2, 3, 2) + b.expand(2, 3, 2)Out:tensor([[[1., 1.],             [1., 1.],             [1., 1.]],
             [[1., 1.],             [1., 1.],             [1., 1.]]])

02

索引操作

索引和切片是NumPy和PyTorch中的两种常用操作,本节将从基本索引入手,对比介绍高级索引的相关用法,帮助建立向量化思想。

2.1 基本索引

PyTorch中Tensor的索引和NumPy数组的索引类似,通过索引操作可以定位到数据的具体位置,也可以进行切片操作。基本索引有以下几种形式。

  • 元组序列:在索引中直接使用一个元组序列对Tensor中数据的具体位置进行定位,也可以直接使用多个整数(等价于元组序列省略括号的形式)代替。

  • 切片对象(Slice Object):在索引中常见的切片对象形如start:stop:step,对一个维度进行全选时可以直接使用:。

  • 省略号(...):在索引中常用省略号来代表一个或多个维度的切片。

  • None:与NumPy中的newaxis相同,None在PyTorch索引中起到增加一个维度的作用。

下面举例说明这几种基本索引的使用方式。

2.1.1 元组序列​​​​​​​

In: a = t.arange(1, 25).view(2, 3, 4)    aOut:tensor([[[ 1,  2,  3,  4],             [ 5,  6,  7,  8],             [ 9, 10, 11, 12]],
            [[13, 14, 15, 16],             [17, 18, 19, 20],             [21, 22, 23, 24]]])In: # 提取位置[0, 1, 2]的元素    # 等价于a[(0, 1, 2)](保留括号的元组形式)    a[0, 1, 2]Out:tensor(7)

注意:a[0, 1, 2]与a[[0, 1, 2]]、a[(0, 1, 2),]并不等价,后面两个不满足基本索引的条件,既不是一个元组序列又不是一个切片对象,它们属于高级索引的范畴,这部分内容将在后文进行讲解。

2.1.2 : 和 ...

在实际编程中,经常会在Tensor的任意维度上进行切片操作,PyTorch已经封装好了两个运算符:和...,它们的用法如下。

  • :常用于对一个维度进行操作,基本的语法形式是:start:end:step。单独使用:代表全选这个维度,start和end为空分别表示从头开始和一直到结束,step的默认值是1。

  • ...用于省略任意多个维度,可以用在切片的中间,也可以用在首尾。

下面举例说明这两个运算符的使用方法:​​​​​​​

In: a = t.rand(64, 3, 224, 224)    print(a[:,:,0:224:4,:].shape) # 第三个维度间隔切片    # 省略startend代表整个维度    print(a[:,:,::4,:].shape)Out:torch.Size([64, 3, 56, 224])    torch.Size([64, 3, 56, 224])In: # 使用...代替一个或多个维度,建议一个索引中只使用一次    a[...,::4,:].shape    # a[...,::4,...].shape # 如果将最后一个维度也改为...,那么在匹配维度时将混乱出错Out:torch.Size([64356224])

2.1.3 None索引

在PyTorch的源码中,None索引经常被使用。None索引可以直观地表示维度的扩展,在广播法则中充当1的作用。使用None索引,本质上与使用unsqueeze函数是等价的,都能起到扩展维度的作用。在维度较多的情况下,或者需要对多个维度先进行扩展再进行矩阵计算时,使用None索引会更加清晰直观。因此,推荐使用None索引进行维度的扩展,下面举例说明:​​​​​​​

In: a = t.rand(2, 3, 4, 5)    # 在最前面加一个维度,下面两种写法等价    print(a.unsqueeze(0).shape)    print(a[None, ...].shape)Out:torch.Size([1, 2, 3, 4, 5])    torch.Size([1, 2, 3, 4, 5])In: # 在原有的四个维度中均插入一个维度,成为(2,1,3,1,4,1,5    # unsqueeze方法,每成功增加一个维度,都需要重新计算下一个需要增加的维度位置    b = a.unsqueeze(1)    b = b.unsqueeze(3)    b = b.unsqueeze(5)    b.shapeOut:torch.Size([2, 1, 3, 1, 4, 1, 5])In: # None索引方法,直接在需要增加的维度上填写None即可    a[:,None,:,None,:,None,:].shapeOut:torch.Size([2131415])

2.2 高级索引

与基本索引相比,高级索引的触发条件有所不同,常见的高级索引遵循以下三个规律。

  • 索引是一个非元组序列:例如tensor[(0, 1, 2),]。

  • 索引是一个整数类型或者布尔类型的Tensor。

  • 索引是元组序列,但是里面至少包含一个整数类型或者布尔类型的Tensor。

2.2.1 整数数组索引

对于整数数组索引(Integer Array Indexing),一般情况下需要先确定输入输出Tensor的形状,这是因为所有的整数索引都有一个相对固定的模式:   

其中  的大小必须小于等于这个Tensor的维度。如果经过索引操作后得到的Tensor形状是  ,那么这个Tensor的所有索引  的形状都必须是  ,同时输出的第  个元素是

如果index的形状不完全相同,但是满足广播法则,那么它们将自动对齐成一样的形状,从而完成整数数组索引操作。对于不能够广播或者不能够得到相同形状的索引,无法进行整数数组索引操作。下面举例说明:​​​​​​​

In: a = t.arange(12).view(3, 4)    # 相同形状的index索引    # 获取索引为[1,0][2,2]的元素    a[t.tensor([1, 2]), t.tensor([0, 2])]Out:tensor([ 4, 10])In: # 不相同形状的index索引,满足广播法则    # 获取索引为[1,0][2,0][1,2][2,2]的元素    a[t.tensor([1,2])[None,:], t.tensor([0, 2])[:,None]]Out:tensor([[ 4,  8],            [ 610]])

有时高级索引与基本索引需要混合使用,这时候基本索引(如切片对象、省略号、None等)会将高级索引切分成多个区域。假设高级索引idx1,idx2,idx3的形状都是  ,tensor[idx1, idx2, idx3]的输出形状即为  。如果将部分高级索引替换为基本索引,那么会先计算高级索引部分的维度,然后补齐输出结果的维度,通常有以下几种情况。

  • 所有的高级索引都处于相邻的维度:例如tensor[idx1, :, :]或者tensor[:, idx2, idx3],那么直接将所有高级索引所在区域的维度转换成高级索引的维度,Tensor的其他维度按照基本索引正常计算。

  • 基本索引将多个高级索引划分到不同区域:例如tensor[idx1, :, idx3],那么统一将高级索引的维度放在输出Tensor维度的开头,剩下部分补齐基本索引的维度。这时所有的高级索引并不相邻,无法确定高级索引的维度应该替换Tensor的哪些维度,因此统一放到开头位置。

下面举例说明:​​​​​​​

In: a = t.arange(24).view(2, 3, 4)    idx1 = t.tensor([[1, 0]]) # shape 1×2    idx2 = t.tensor([[0, 2]]) # shape 1×2    # 所有的高级索引相邻    a[:, idx1, idx2].shapeOut:torch.Size([2, 1, 2])In: # 手动计算输出形状    # a的第一个维度保留,后两个维度是索引维度    a.shape[0], idx1.shapeOut:(2, torch.Size([1, 2]))In: a = t.arange(120).reshape(2, 3, 4, 5)    # 中间两个维度替换成高级索引的维度    a[:, idx1, idx2, :].shapeOut:torch.Size([2, 1, 2, 5])In: # 高级索引被划分到不同区域    # 高级索引的维度放在输出维度的最前面,剩下的维度依次补齐    a[idx1, :, idx2].shapeOut:torch.Size([1235])In: a[:,idx1,:,idx2].shapeOut:torch.Size([1224])

整数数组索引是根据索引数组(  )来选取Tensor中的任意项。每个索引数组(  )代表该维度的多个索引,所有的索引数据(  )必须形状一致,具体可以分为以下两种情况。

  • 当索引数组的个数等于Tensor的维度数时,索引输出的形状等价于  的形状,输出的每一个元素等价于  。

  • 当索引数组的个数小于Tensor的维度数时,类似于切片操作,将这个切片当做索引操作的结果。

下面来看几个示例:​​​​​​​

In: a = t.arange(12).view(3, 4)    print(a)    print(a[[2,0]]) # 索引数组个数小于a的维度数    # 索引数组个数等于a的维度数    # 获取索引为[1,3][2,2][0,1]的元素    print(a[[1, 2, 0], [3, 2, 1]]) Out:tensor([[ 0,  1,  2,  3],            [ 4,  5,  6,  7],            [ 8,  9, 10, 11]])    tensor([[ 8,  9, 10, 11],            [ 0,  1,  2,  3]])    tensor([ 7, 10,  1])In: # 输出形状取决于索引数组的形状    # 获取索引为[0,1][2,3][1,3][0,1]的元素    idx1 = t.tensor([[0, 2], [1, 0]])    idx2 = t.tensor([[1, 3], [3, 1]])    a[idx1, idx2]Out:tensor([[ 1, 11],            [ 7,  1]])

从上面的例子可以看出,整数数组索引的机制就是先将索引数组对应位置的数字,组合成源Tensor实例的索引,再根据索引值和Tensor的size、storage_offset和stride属性计算出Storage空间上的真实索引,最后返回结果。如果索引数组的个数小于Tensor的维度数,那么缺少的部分需要对整个轴进行完整的切片,再重复上述过程。

注意:不能先对索引数组进行组合,再进行索引操作。如果只有一个索引数组,那么该数组会被视为第一个维度上的索引,示例如下:​​​​​​​

In: # 错误示范    idx1 = [[0, 2], [1, 0]]    idx2 = [[1, 3], [3, 1]]    idx = t.tensor([idx1, idx2]) # 提前将索引数组进行组合    # a[idx]    # 如果报错,表示超出了索引范围    # 没报错,但是结果不是想要的结果。这是因为只索引了第一个维度,后面的维度直接进行切片

2.2.2 布尔数组索引

在高级索引中,如果索引数组的类型是布尔型,那么就会使用布尔数组索引(Boolean Array Indexing)。布尔类型的数组对象可以通过比较运算符产生,下面举例说明:​​​​​​​

In: a = t.arange(12).view(3, 4)    idx_bool = t.rand(3, 4) > 0.5    idx_boolOut:tensor([[ True,  True,  True,  True],            [False, False, False, False],            [False, False, False, False]])In: a[idx_bool] # 返回idx_bool中为True的部分Out:tensor([0, 1, 2, 3])

布尔数组索引常用于对特定条件下的数值进行修改。例如,对一个Tensor中的所有正数进行乘2操作,最直观的方法是写一个for循环,遍历整个Tensor,对满足条件的数进行计算。​​​​​​​

In: # 利用for循环    a = t.tensor([[1, -3, 2], [2, 9, -1], [-8, 4, 1]])    for i in range(a.shape[0]):        for j in range(a.shape[1]):            if a[i, j] > 0:                a[i, j] *= 2    aOut:tensor([[ 2, -3,  4],            [ 4, 18, -1],            [-8,  8,  2]])

此时,可以使用布尔数组索引来简化运算:

In: # 利用布尔数组索引    a = t.tensor([[1, -3, 2], [2, 9, -1], [-8, 4, 1]])    a[a > 0] *= 2    aOut:tensor([[ 2, -3,  4],            [ 4, 18, -1],            [-8,  8,  2]])

2.3 einsum / einops

在高级索引中还有一类特殊方法:爱因斯坦操作。下面介绍两种常用的爱因斯坦操作:einsum和einops,它们被广泛地用于向量、矩阵和张量的运算。灵活运用爱因斯坦操作可以用非常简单的方式表示较为复杂的多维Tensor之间的运算。

2.3.1 einsum

在数学界中,有一个由爱因斯坦提出来的求和约定,该约定能够有效处理坐标方程。爱因斯坦求和(einsum)就是基于这个法则,省略求和符号和默认成对出现的下标,从而完成对向量、矩阵和张量的运算,下面举例说明:​​​​​​​

In: # 转置操作    import torch as t    a = t.arange(9).view(3, 3)    b = t.einsum('ij->ji', a) # 直接交换两个维度    print(a)    print(b)Out:tensor([[0, 1, 2],            [3, 4, 5],            [6, 7, 8]])    tensor([[0, 3, 6],            [1, 4, 7],            [2, 5, 8]])In: # 求和操作    a = t.arange(36).view(3, 4, 3)    b = t.einsum('ijk->', a) # 所有元素求和    bOut:tensor(630)In: # 多个张量之间的混合运算    a = t.arange(6).view(2, 3)    b = t.arange(3)    # 矩阵对应维度相乘,b进行了广播    t.einsum('ij,j->ij', a, b)Out:tensor([[ 0,  1,  4],            [ 0,  4, 10]])In: # 直观表达矩阵的内积和外积    a = t.arange(6).view(2, 3)    b = t.arange(6).view(3, 2)    c_in = t.einsum('ij,ij->', a, a) # 内积,结果是一个数    c_out = t.einsum('ik,kj->ij', a, b) # 外积,矩阵乘法的结果    print(c_in)    print(c_out)Out:tensor(55)    tensor([[10, 13],            [28, 40]])

2.3.2 einops

除了上面介绍的爱因斯坦求和,其他的爱因斯坦操作都封装在einops中,它支持NumPy、PyTorch、Chainer、TensorFlow等多种框架的数据格式。在爱因斯坦操作中,多次转置操作不再使用tensor_x.transpose(1, 2).transpose(2, 3),而是用更直观的方式:rearrange(tensor_x, 'b c h w -> b h w c')代替。

einops有很多复杂的操作,这里仅讲解最常见、最直观的用法,并分析如何在深度学习框架中高效使用einops操作。有关einops更详细的内容示例和底层实现可以参考einops的说明文档。​​​​​​​

In: from einops import rearrange, reduce    a = t.rand(16, 3, 64, 64) # batch × channel × height × weight    # 转置操作    rearrange(a, 'b c h w -> b h w c').shapeOut:torch.Size([16, 64, 64, 3])In: # 融合部分维度    y = rearrange(a, 'b c h w -> b (h w c)') # flatten    y.shapeOut:torch.Size([1612288])

爱因斯坦操作凭借其便捷、直观的特点,在视觉Transformer中得到了广泛的应用。假设输入是256×256×3的彩色图像,根据Transformer的要求,现在需要将其划分成8×8=64个块,每个块有32×32×3=3072个像素,使用爱因斯坦操作实现如下:

In: img = t.randn(1, 3, 256, 256)    x = rearrange(img, 'b c (h p1) (w p2) -> b (p1 p2) (h w c)', p1=8, p2=8)    x.shapeOut:torch.Size([1, 64, 3072])

在很多网络结构中,需要提取通道间或者空间像素之间的信息,从而完成通道的部分维度和空间的部分维度之间的转化。直接使用索引等操作会比较烦琐,einops操作可以直观地完成这个过程:​​​​​​​

In: # Space to Depth    b = t.rand(16, 32, 64, 64)    s2d = rearrange(b, 'b c (h h0) (w w0) -> b (h0 w0 c) h w', h0=2, w0=2)    # Depth to Space    d2s = rearrange(b, 'b (c h0 w0) h w -> b c (h h0) (w w0)', h0=2, w0=2)    print("Space to Depth: ", s2d.shape)    print("Depth to Space: ", d2s.shape)Out:Space to Depth:  torch.Size([16, 128, 32, 32])    Depth to Space:  torch.Size([16, 8, 128, 128])

除了rearrange,常见的einops操作还有reduce,它常用于求和、求均值等操作,同时也用于搭建卷积神经网络中的池化层,下面举例说明:​​​​​​​

In: # 对空间像素求和    y = reduce(a, 'b c h w -> b c', reduction='sum')    y.shape # 对h和w维度求和Out:torch.Size([16, 3])In: # 全局平局池化    global_avg_pooling = reduce(a, 'b c h w -> b c', reduction='mean')    global_avg_pooling.shape Out:torch.Size([16, 3])

einops的所有操作都支持反向传播,可以有效地嵌入到深度学习模型框架中,示例如下:​​​​​​​

In: x0 = t.rand(16, 3, 64, 64)    x0.requires_grad = True    x1 = reduce(x0, 'b c h w -> b c', reduction='max')    x2 = rearrange(x1, 'b c -> c b')    x3 = reduce(x2, 'c b -> ', reduction='sum')
    x3.backward()    x0.grad.shapeOut:torch.Size([16, 3, 64, 64])

03

向量化的简单应用

向量化思想可以解决深度学习中的很多经典问题,例如实现img2col快速卷积算法、在目标检测中计算检测结果框与ground truth的交并比(IoU)以及实现RCNN网络中的RoI Align算法等。这里我们以反向Unique函数为例进行说明。

在PyTorch中有一个unique函数,它的功能是返回输入Tensor中不同的元素组成的unique list,同时返回输入Tensor对应于这个unique list的索引。当拿到了这个unique list和对应的索引,能否还原出输入的Tensor呢?

答案是肯定的。最简单的思路是遍历这个索引,逐个生成输入Tensor对应位置的元素,最后进行组合即可。这个过程比较繁琐,可以考虑使用高级索引解决这个问题。根据上文中整数数组索引的思路,这个索引的size和目标Tensor的size是一致的,因此可以直接使用整数数组索引对原始Tensor进行构建,具体实现如下:​​​​​​​

In: # 随机生成一组形状为(10, 15, 10, 5)、0~9数字组成的张量    a = t.randint(1, 10, (10, 15, 10, 5))    # 获取输出的unique list和索引    output, inverse_indices = t.unique(a, return_inverse=True)    # 通过整数数组索引 还原原始tensor    a_generate = output[inverse_indices]    a_generate.equal(a)Out:True

上述结果可以看出,还原的Tensor值与原始值一致,这意味着使用高级索引方法可以便捷地完成反向unique操作,从而避免了耗时较长的循环遍历操作。

04

总结

本文对PyTorch中的向量化计算与高级索引进行了详细介绍。向量化思想在高维数据处理时能够有效提升计算效率,高级索引操作可以帮助用户灵活地对Tensor进行取值、切片等操作,以便进行更加复杂的计算。读者可以仔细体会其中的向量化思想,并在解决实际问题时尝试使用向量化思想进行编程,从而提高程序的运行效率。

 

声明:本文内容由网友自发贡献,转载请注明出处:【wpsshop博客】
推荐阅读
相关标签
  

闽ICP备14008679号