Pytorch与深度学习 —— 3. 广播、数据访问与轴方向运算

冷不防 2022-09-04 09:59 212阅读 0赞

### 文章目录 ###

*  广播机制
 *   *  张量与常数之间的广播
     *  张量与张量之间的广播
 *  数据访问
 *   *  基于下标的引索
     *   *  1D
         *  2D
         *  3D
     *  切片
     *   *  1D
         *  2D
         *  3D
     *  高级引索
 *  按轴方向计算
 *   *  dim = 0 时
     *  dim = 1 时
     *  dim = 2 时

这是 Pytorch 里的一个知识点。由于Torch 的底层，参考了很多 numpy 的设计理念。所以也带入了很多 numpy 才有独有的概念。其中最主要的三个特性，广播机制、数据访问，以及按轴方向计算。由于 torch 中很多操作可能会涉及这三个基本概念，所以在这一章里我们也来聊一下这些东西。

虽然我打算在第三章介绍这部分的内容，但是如果你是第一次接触Python语言的科学计算框架。没有接触过Numpy、Pandas、Scikit-Learn之类的话，我建议你可以先跳过这一章节，学习后面的内容。等基本掌握了PyTorch后再作为知识补充回看这一部分的章节内容。

# 广播机制 #

广播是以Numpy为代表的科学计算框架的一个重要技术特点。它相当于约定了几种对于矩阵数据的传递、更新方法。对于二维矩阵来说，它相当于两个for循环。

void serial_matrix_update(...) {
            for (int i = 0; i < mat.cols(); i++) {
                    for (int j = 0; j < mat.rows(); j++) {
                            // update the elements in a matrix
                            mat[i][j] = newval;
                    }
            }
    }

只不过，对于Numpy来说，这里的循环计算通过了CPU并行线程的形式，进行了加速处理。比如说对于 OpenMP 来说，就可以利用并行命令，实现对矩阵的并行运算。

void parallel_matrix_update(...) {
    # pargma omp parallel for num_threads(16)
            for (int i = 0; i < mat.cols(); i++) {
                    for (int j = 0; j < mat.rows(); j++) {
                            // update the elements in a matrix
                            mat[i][j] = newval;
                    }
            }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BvaXNvbmNocnk_size_16_color_FFFFFF_t_70_pic_center]

由于采用了并行计算技术，自然Numpy也比其他Python科学框架有了性能上的提高。而为了尽可能避免用户自己设计低效的多的线性计算，Numpy把矩阵中常用的元素计算过程都封装了。并提供了所谓广播的机制供用户使用。

而torch与Numpy由于底层原理基本相似，只不过torch还提供了基于GPU的广播，所以其数据处理能力更为强大。

## 张量与常数之间的广播 ##

这部分最容易理解，从矩阵的基本运算出发，通常我们以空心字母表示矩阵，例如： M \\mathbb\{M\} M，以实心小写字母表示常数，例如  c c c，它们的运算关系表示如下：

M ⋆ c = \[ M 00 ⋆ c , M 01 ⋆ c , ⋯   , M 0 m ⋆ c M 10 ⋆ c , M 11 ⋆ c , ⋯   , M 1 m ⋆ c ⋮ ⋮ M n 0 ⋆ c , M n 1 ⋆ , ⋯ M n m ⋆ c \] \\mathbb\{M\} \\star c = \\begin\{bmatrix\} M\_\{00\} \\star c, & M\_\{01\} \\star c, & \\cdots, & M\_\{0m\} \\star c \\\\ M\_\{10\} \\star c, & M\_\{11\} \\star c, & \\cdots, & M\_\{1m\} \\star c \\\\ \\vdots & & & \\vdots \\\\ M\_\{n0\} \\star c, & M\_\{n1\} \\star, & \\cdots & M\_\{nm\} \\star c \\end\{bmatrix\} M⋆c=⎣⎢⎢⎢⎡M00⋆c,M10⋆c,⋮Mn0⋆c,M01⋆c,M11⋆c,Mn1⋆,⋯,⋯,⋯M0m⋆cM1m⋆c⋮Mnm⋆c⎦⎥⎥⎥⎤

⋆ \\star ⋆ 可以是  \+ − × ÷ + - \\times \\div \+−×÷。

所以对于torch来说，我们可以让张量直接和常量做运算，这个过程会自动进行广播，例如：

>>> mat_1 = torch.randn(4, 4)
    >>> mat_2 = mat_1 + 15
    >>> mat_2
    tensor([[14.4729, 13.9290, 16.4399, 15.4899],
            [13.8327, 15.1902, 13.2310, 15.9114],
            [15.2635, 14.2937, 14.5562, 14.7718],
            [13.7188, 15.0022, 15.5085, 17.2269]])

如果要对张量通过广播的形式进行赋值，那么这个操作是这样的：

>>> mat_1 = torch.randn(4, 4)
    >>> mat_1[:] = 15
    tensor([[15., 15., 15., 15.],
            [15., 15., 15., 15.],
            [15., 15., 15., 15.],
            [15., 15., 15., 15.]])

对于三维的赋值又是这样的：

>>> mat_1 = torch.randn(4, 4, 4)
    >>> mat_1[::] = 15
    tensor([[[15., 15., 15., 15.],
             [15., 15., 15., 15.],
             [15., 15., 15., 15.],
             [15., 15., 15., 15.]],
    
            [[15., 15., 15., 15.],
             [15., 15., 15., 15.],
             [15., 15., 15., 15.],
             [15., 15., 15., 15.]],
    
            [[15., 15., 15., 15.],
             [15., 15., 15., 15.],
             [15., 15., 15., 15.],
             [15., 15., 15., 15.]],
    
            [[15., 15., 15., 15.],
             [15., 15., 15., 15.],
             [15., 15., 15., 15.],
             [15., 15., 15., 15.]]])

那么一维呢？

>>> mat_1 = torch.randn(4)
    >>> mat_1[:] = 0
    tensor([0., 0., 0., 0.])

## 张量与张量之间的广播 ##

在前面的章节里，其实我已经提到一点广播的运算。只不过在这一节里，稍微再多说一下。张量对张量的广播，相对较难理解，对于Numpy这类框架来说，这也是一个经常易错点。

因为不是所有的张量彼此之间都可以做广播的，错误的维度之间进行广播运算，会导致程序出错而。可以进行广播的张量，或者说矩阵，必须满足如下规定1：

*  ndim较小的数组会在前面追加一个长度为 1 的维度。
 *  输出数组的每个维度的大小是输入数组该维度大小的最大值。
 *  如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。
 *  如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。

![在这里插入图片描述][1c77dd0e289143d692556f3bf0c12321.jpg_pic_center]

简单的来说，对于二维张量（矩阵） ( M × N ) (M \\times N) (M×N) 来说，对它广播机制起作用的张量纬度应该是  ( 1 × N ) (1 \\times N) (1×N)。

如果对于三维张量  ( L × M × N ) (L \\times M \\times N) (L×M×N)，对它广播机制起作用的张量纬度可以是  ( 1 × 1 × N ) (1 \\times 1 \\times N) (1×1×N) 或  ( 1 × M × N ) (1 \\times M \\times N) (1×M×N)。

对于更高维度的张量可以用类似方法推算出生效的纬度。

>>> mat_1 = torch.randn(4, 5)
    >>> mat_1
    tensor([[ 0.5495, -1.7738, -1.2531, -0.5100, -2.3284],
            [-0.8322,  0.0097,  0.1181, -0.3274,  0.7187],
            [-0.3529,  0.3882,  0.4880,  2.4768,  0.8127],
            [-0.6307,  1.0264,  1.2032, -0.5523, -1.3043]])
    >>> mat_2 = torch.zeros(1, 5)
    >>> mat_2[:] = 2
    >>> mat = mat_1 * mat_2
    tensor([[ 1.0990, -3.5476, -2.5063, -1.0200, -4.6567],
            [-1.6643,  0.0195,  0.2362, -0.6548,  1.4373],
            [-0.7058,  0.7764,  0.9759,  4.9536,  1.6254],
            [-1.2614,  2.0529,  2.4063, -1.1045, -2.6087]])

# 数据访问 #

torch 与 numpy 一样，提供了丰富的元素访问方法，除了最简单的基于下标的访问方法外。还提供了切片，和引索方法。在这里我们主要介绍一些常用的方法，其他的一些高级访问方法，如果有需要的时候，你可以去网上搜索一下。

## 基于下标的引索 ##

### 1D ###

>>> mat_1 = torch.randn(10)
    tensor([-0.8354,  0.3910, -0.6015,  0.0374,  0.9353,  1.0283, -1.3340,  0.5558,
             0.4011,  0.5681])
    >>> mat_1[5]
    tensor(1.0283)

### 2D ###

>>> mat_1 = torch.randn(5, 5)
    tensor([[-0.5041, -0.1096,  2.2758,  1.3238, -0.6370],
            [ 0.9520, -1.0824, -0.3485, -0.8974,  1.1378],
            [-0.5751,  0.3864, -0.7496,  0.1130, -1.9772],
            [ 1.7763, -0.1558,  0.9076,  0.2319, -0.2310],
            [ 2.1147,  0.6988, -0.3130, -0.6016,  0.8416]])
    
    >>> mat_1[2, 3]
    tensor(0.1130)

### 3D ###

>>> mat_1 = torch.randn(5, 5, 3)
    tensor([[[ 1.5499, -1.2722, -0.6003],
             [ 0.5930,  1.1061, -0.2126],
             [ 0.2229, -1.3852,  0.3954],
             [ 1.4545, -0.0476, -0.4687],
             [-1.1546,  0.0732, -0.5409]],
    
            [[-0.3405, -0.8253,  1.3972],
             [-0.1557, -0.4042,  0.3433],
             [-0.8347, -1.3775, -0.2870],
             [-0.4138, -1.6406, -0.0408],
             [-0.4564,  0.4605,  0.1197]],
    
            [[ 1.7200,  1.6114, -0.8540],
             [-2.0958, -0.7073,  1.0321],
             [-0.4447,  1.0803,  0.4932],
             [ 0.4449, -0.1097,  0.6529],
             [ 0.0547,  0.0688, -0.8448]],
    
            [[ 1.0546, -0.0107,  0.1730],
             [-0.0537,  0.3797, -0.6770],
             [ 1.9510, -0.0396,  2.1235],
             [-1.5306, -1.2248,  1.4522],
             [-1.7704,  0.9935, -3.1246]],
    
            [[-0.3685,  0.3350, -0.9457],
             [ 0.4277, -0.2691,  0.5647],
             [ 0.0624,  0.1205,  1.2472],
             [ 0.6732,  0.8292,  0.3344],
             [-0.0040, -0.5328, -0.6222]]])
    >>> mat_1[2, 2, 2]
    tensor(0.4932)

## 切片 ##

所谓切片，就是从数据中选取一块的方法。尽管 Python 本身提供了最基本的切片方法。但是 Numpy 以及相似的数学框架，都提供了更为强大的切片方法。切片在单纬度上，需要最多三个参数，表示为 \[start:stop:step\]：

*  start，数据开始位
 *  stop，数据停止位
 *  step，步长

在实际使用时，不需要都填入三个参数。仅一个参数的时候，可以表示从 xxx 开始，例如\[a:\]；也可以表示 到 xxx 结束，例如\[:a\]。

仅两个参数时，通常表示从 xxx 开始，到 xxx 结束，例如\[a:b\]。

除此以外，还可以 start/stop/step某一位或两位留空（默认值）的形式，例如\[:b :2\]；它表示说对于数组，取切片从最初数据开始，到b停止，步长为2.

那么接下来我们来看看，如何在torch上取1D，2D，以及3D的切片

### 1D ###

>>> mat_1 = torch.randn(10)
    tensor([-0.7847, -1.3034, -0.3024, -0.5151, -0.5259,  0.0976, -0.4035, -0.1554,
            -0.7031,  0.0685])
    >>> mat_1[2:4]
    tensor([-0.3024, -0.5151])

### 2D ###

>>> mat_1 = torch.randn(5, 5)
    tensor([[ 1.4727,  0.8752, -1.1659, -0.5395, -0.2003],
            [ 0.6098,  1.2986, -0.2280,  0.6363, -2.0727],
            [-1.1190,  0.9222,  1.0509, -0.5275,  0.0123],
            [-2.3558, -0.7528, -0.5821, -0.0617,  2.3123],
            [ 0.7983,  0.8631,  0.5254,  0.4015,  0.5859]])
    >>> mat_1[2:4, 2:4]
    tensor([[ 1.0509, -0.5275],
            [-0.5821, -0.0617]])

### 3D ###

>>> mat_1 = torch.randn(5, 5, 5)
    tensor([[[ 0.2585,  0.0486, -0.6875, -0.7236, -1.4624],
             [ 1.8448,  0.1578, -0.2856, -0.8087,  0.8832],
             [ 0.6448, -0.2870, -0.0935, -0.1665,  0.1877],
             [ 1.1900,  0.4233, -0.0181,  0.2601, -1.2189],
             [-0.8177, -0.1180,  0.0675, -0.4356,  0.2083]],
    
            [[ 0.1104,  0.9087, -0.5323,  0.7636,  0.9266],
             [-1.9928, -1.2918, -0.1089, -1.8328,  0.4754],
             [-0.5195, -0.8302, -1.6530, -1.0996,  1.9016],
             [-0.4862,  1.4479,  1.5211, -0.0900,  0.2471],
             [ 0.1940,  0.5009, -1.5404, -1.2031,  3.0326]],
    
            [[-1.0347,  1.1821,  1.5768, -1.2568, -0.7130],
             [ 0.0603, -1.6971,  0.9823, -0.4181,  0.3773],
             [-0.1673, -0.1203, -1.0798, -0.5098,  0.2918],
             [ 0.4707,  0.8853, -1.0017, -0.4030, -0.0537],
             [-1.1501,  0.3699, -0.2750,  0.6284,  0.5299]],
    
            [[-2.0714,  1.1672, -0.1735, -1.3095,  0.2075],
             [-1.4994,  0.0735,  0.0942, -1.1126, -0.9389],
             [ 0.4393, -0.6685, -0.4475,  0.3692,  0.4645],
             [-0.4688,  0.4776, -0.3455, -0.2724, -0.8578],
             [-1.5485,  0.2807,  0.9715,  0.2459,  0.1632]],
    
            [[ 1.4978,  0.6009,  0.6048,  1.2246,  0.9760],
             [-0.3099, -0.4292, -1.2511, -0.7627, -0.2480],
             [-1.8970,  1.1567,  0.1742,  0.1392, -0.0385],
             [-0.6332,  0.9520, -1.4645, -1.6097,  0.3585],
             [-0.8561,  1.8119, -0.0147, -0.8631, -0.5188]]])
    >>> mat_1[2:4, 2:4, 2:4]
    tensor([[[-1.0798, -0.5098],
             [-1.0017, -0.4030]],
    
            [[-0.4475,  0.3692],
             [-0.3455, -0.2724]]])

## 高级引索 ##

这是 numpy 为代表的数学框架特有的功能，与切片的数据访问方式不同，高级引索甚至允许你定义一些查询条件，以便于更为自由的数据检索。

这一小节，我们以二维张量做演示，说明高级引索是这么使用的。

>>> mat_1 = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
    tensor([[ 0,  1,  2],
            [ 3,  4,  5],
            [ 6,  7,  8],
            [ 9, 10, 11]])
    >>> mat_1[mat_1 > 5]
    tensor([ 6,  7,  8,  9, 10, 11])

这里发生了什么事？

首先，执行 mat\_1 > 5 时，会产生一个 mask 张量，它的值是这样：

>>> mat_1 > 5
    tensor([[False, False, False],
            [False, False, False],
            [ True,  True,  True],
            [ True,  True,  True]])

这个 mask 被用来对原始的数据进行判断，只有当True时，才会写入到新的张量里。

# 按轴方向计算 #

在torch的函数中，有很多都有 **dim** 这个参数。文档说法是，这决定了张量操作沿着某个轴进行，但是这个轴的定义又不是我们理解的XYZ轴，而是数据的存储结构。所以，我个人觉得这是个比较难理解的地方，所以我这里直接引用别人的文章，并且贴三张动图以示说明，如果你有需要可以去[原贴][Link 1]看看。

作者以 sum 运算为例：

## dim = 0 时 ##

![在这里插入图片描述][8ac9500bfead437b972eb1ef9f350a6c.gif_pic_center]

## dim = 1 时 ##

![在这里插入图片描述][8312380e544e4e1597b38079af5d9176.gif_pic_center]

## dim = 2 时 ##

![在这里插入图片描述][75ead7be5616462f9a7fc09e3d010a50.gif_pic_center]

--------------------

1.  https://www.yiibai.com/numpy/numpy\_broadcasting.html ↩︎

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3BvaXNvbmNocnk_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/10cf39410ba443928af8cf74006c37e1.png
[1c77dd0e289143d692556f3bf0c12321.jpg_pic_center]: /images/20220829/5dcfe2be933045b18c183a3c6c898a0d.png
[Link 1]: https://towardsdatascience.com/understanding-dimensions-in-pytorch-6edf9972d3be
[8ac9500bfead437b972eb1ef9f350a6c.gif_pic_center]: /images/20220829/880c2e60821442b7aad7af5df3dc1cd6.png
[8312380e544e4e1597b38079af5d9176.gif_pic_center]: /images/20220829/f009e34bbcf448c48814c1913c1f4ce3.png
[75ead7be5616462f9a7fc09e3d010a50.gif_pic_center]: /images/20220829/39cc763042764dd9b11022d9b83a7500.png