摘自https://zhuanlan

• axis就是计数方式，直白来说就是最外面的括号代表axis=0, 依次往里面的括号对应的axis技术就依次+1

比方说对于矩阵
$$
x = begin{bmatrix}
0 & 1
2 & 3
end{bmatrix}
$$
在numpy里面，这个矩阵表达成x=[[0,1],[2,3]],则最外层的括号代表axis=0,里面一层的括号代表axis=1

所以对应的运算就有

更加高维的运算：

• 设axis=i,则numpy就沿着第i个下标变化的方向进行操作**

比方说np.sum(a, axis=1)二维数组
$$
begin{bmatrix}
begin{bmatrix}
1, &2, &3
end{bmatrix},
begin{bmatrix}
4, &5, &6
end{bmatrix},
begin{bmatrix}
7, &8, &9
end{bmatrix}
end{bmatrix}
$$

就会朝着a[0][i](i=0,1,2)的方向变化,就是a[0][1],a[0][2],a[0][3]相加变成6

$$
begin{bmatrix}
begin{bmatrix}
6
end{bmatrix},
begin{bmatrix}
15
end{bmatrix},
begin{bmatrix}
24
end{bmatrix}
end{bmatrix}
$$

​ 再看一个三维数组:

如果要计算np.sum(a, axis=1),则这个时候就是a[0][i](i=0,1)的方向进行变化,也就是对于a[0][0],a[0][1]相加,即
$$
begin{bmatrix}
[1,2,3,4] + [1,3,4,5]
end{bmatrix}
$$
变成
$$
begin{bmatrix}
[2,5,7,9]
end{bmatrix}
$$

​ 再看一个十分复杂的思维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

a = np.arange(72).reshape(4,3,2,3)
a
[[[[ 0  1  2]
   [ 3  4  5]]

  [[ 6  7  8]
   [ 9 10 11]]

  [[12 13 14]
   [15 16 17]]]


 [[[18 19 20]
   [21 22 23]]

  [[24 25 26]
   [27 28 29]]

  [[30 31 32]
   [33 34 35]]]


 [[[36 37 38]
   [39 40 41]]

  [[42 43 44]
   [45 46 47]]

  [[48 49 50]
   [51 52 53]]]


 [[[54 55 56]
   [57 58 59]]

  [[60 61 62]
   [63 64 65]]

  [[66 67 68]
   [69 70 71]]]]

那么如果np.sum(a, axis=0),则意味着a[i](i=0,1,2,3)依次相加,也就是a[0],a[1],a[2],a[3]依次相加,a0000+a1000+a2000+a3000=0+18+36+54=108,第二个a0001+a1001+a2001+a3001=1+19+37+55=112,其最终相加之后的结构也应该等于a[0]的结构,也就是一个shape为(3,2,3)的数组:

1
2
3
4
5
6
7
8

[[[108 112 116]
  [120 124 128]]

 [[132 136 140]
  [144 148 152]]

 [[156 160 164]
  [168 172 176]]]

如果axis = 1,则相当于a0000+a0100+a0200=0+6+12=18,axis=1最终的结构应该相当于4个a[0][0],也就是

1
2
3
4
5
6
7
8
9
10
11

[[[ 18  21  24]
  [ 27  30  33]]

 [[ 72  75  78]
  [ 81  84  87]]

 [[126 129 132]
  [135 138 141]]

 [[180 183 186]
  [189 192 195]]]

如果axis=2,则即a[0][0][i](i=0,1)依次相加,a000+a001 = 0+3 = 3,,也就是

[0 1 2]+[3 4 5] = [3 5 7],其最终的结果为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[[[  3   5   7]
  [ 15  17  19]
  [ 27  29  31]]

 [[ 39  41  43]
  [ 51  53  55]
  [ 63  65  67]]

 [[ 75  77  79]
  [ 87  89  91]
  [ 99 101 103]]

 [[111 113 115]
  [123 125 127]
  [135 137 139]]]

如果axis=3,则相当于a[0][0][0][i](i=0,1,2)依次相加,其最终结果为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[[[  3  12]
  [ 21  30]
  [ 39  48]]

 [[ 57  66]
  [ 75  84]
  [ 93 102]]

 [[111 120]
  [129 138]
  [147 156]]

 [[165 174]
  [183 192]
  [201 210]]]

transpose就是更换矩阵的顺序，比方说一个shape为(2,3,4)的矩阵

1
2

import numpy as np
x = np.arrange(24).reshape([2,3,4])

则此时这个
$$
x = begin{bmatrix}
begin{bmatrix}
begin{bmatrix}
0 & 1 & 2 & 3
end{bmatrix}
begin{bmatrix}
4 & 5 & 6 & 7
end{bmatrix}
begin{bmatrix}
8 & 9 & 10 & 11
end{bmatrix}
end{bmatrix}
begin{bmatrix}
begin{bmatrix}
12 & 13 & 14 & 15
end{bmatrix}
begin{bmatrix}
16 & 17 & 18 & 19
end{bmatrix}
begin{bmatrix}
20 & 21 & 22 & 23
end{bmatrix}
end{bmatrix}
end{bmatrix}
$$
首先需要了解shape的直观概念，shape中的各个数就是对应的axis的元素个数，如下图：

所以shape的值为(2,3,4)也就是说对于axis=0,每隔两个元素往下走(每个元素相差12)，对于axis=1，每隔3个元素往下走（每个元素相差4），对于axis=2来说，每隔4个元素往下走（每个元素相差1）

这个时候我们定义另外一个参数strides，记录每个axis跳过的数，则上面的strides=(12,4,1)

那么，transpose的本质就是对strides中的各个数的顺序进行了调换，比方说

1

x.transpose(1,0,2)

则这个时候strides就变成(4,12,1), shape就变成(3,2,4),也就是说一个大的矩阵里面包含三个矩阵b，其中每个b里面又有两个矩阵c, 每个c矩阵里面有4列，画出来就变成这样的形式
$$
x = begin{bmatrix}
begin{bmatrix}
begin{bmatrix}
x & x & x & x
end{bmatrix}
begin{bmatrix}
x & x & x & x
end{bmatrix}
end{bmatrix}
begin{bmatrix}
begin{bmatrix}
x & x & x & x
end{bmatrix}
begin{bmatrix}
x & x & x & x
end{bmatrix}
end{bmatrix}
begin{bmatrix}
begin{bmatrix}
x & x & x & x
end{bmatrix}
begin{bmatrix}
x & x & x & x
end{bmatrix}
end{bmatrix}
end{bmatrix}
$$
这个时候再定义里面strides跳跃，则可以确定此时变换后的矩阵变成：
$$
x = begin{bmatrix}
begin{bmatrix}
begin{bmatrix}
0 & 1 & 2 & 3
end{bmatrix}
begin{bmatrix}
12 & 13 & 14 & 15
end{bmatrix}
end{bmatrix}
begin{bmatrix}
begin{bmatrix}
4 & 5 & 6 & 7
end{bmatrix}
begin{bmatrix}
16 & 17 & 18 & 19
end{bmatrix}
end{bmatrix}
begin{bmatrix}
begin{bmatrix}
8 & 9 & 10 & 11
end{bmatrix}
begin{bmatrix}
20 & 21 & 22 & 23
end{bmatrix}
end{bmatrix}
end{bmatrix}
$$

np.argmax中有一个参数是axis，默认是0，代表第几维的最大值，比方说二维的情况

1
2
3
4
5
6

import numpy as np
a = np.array([[1, 5, 5, 2],
              [9, 6, 2, 8],
              [3, 7, 9, 11]
             ])
print(np.argmax(a, axis=0))

axis=0的含义就是a[0][j],a[1][j], a[2][j] (j=0,1,2,3)中最大值的索引

a[1][j]中9>3, 6>5, 8>2所以此时a[1][j]与a[0][j]相比索引变成(1,1,0,1)

然后a[2][j]再与这个时候的(1,1,0,1)对应的值比较，7>6,9>5,11>8，所以此时的索引值变成(1,2,2,2)

如果axis=1，其含义就是第二维比最大值，a[i][0],a[i][1],a[i][2],a[i][3](i=0,1,2,3)中最大索引的值，所以a[i][0]初始最大索引值为(0,0,0)，然后第二列做比较，则5>1,7>3此时的索引值变为(1,0,1),再和第三列做比较，比较后索引值为(1,0,2),最后和第四列作比较,则这个时候索引值变为(1,0,3)

可以再看一个三维的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import numpy as np
a = np.array([
              [
                  [1, 5, 5, 2],
                  [9, -6, 2, 8],
                  [-3, 7, -9, 1]
              ],

              [
                  [-1, 5, -5, 2],
                  [9, 6, 2, 8],
                  [3, 7, 9, 1]
              ]
            ])
print(np.argmax(a, axis=0))

当axis=0比较的是a[0][j][k],a[1][j][k](j=0,1,2,k=0,1,2,3),a[0]矩阵就是
$$
begin{bmatrix}
begin{bmatrix}
1， & 5， & 5， & 2
end{bmatrix},
begin{bmatrix}
9， & -6， & 2， & 8
end{bmatrix},
begin{bmatrix}
-3， & 7， & -9， & 1
end{bmatrix}
end{bmatrix}
$$
这个时候a[0][j][k]的初始索引值为(0,0,0,0),(0,0,0,0),(0,0,0,0)然后拿a[0][j][k]与a[1][j][k]的对应项去做比较，1>-1,5=5,5>-5,2=2;9=9,-6<6,2=2,8=8;-3<3,7=7,-9<9,1=1则这个时候索引大小变为(0,0,0,0);(0,1,0,0);(1,0,1,0)

如果axis=1,则比较的是a[i][0][k],a[i][1][k],a[i][2][k]对应的项去比较，则初始的索引值为(0,0,0,0),(0,0,0,0),a[0][0][k] vs. a[0][1][k]的索引值为(1,0,0,1),a[1][0][k] vs. a[1][1][k]的索引值为(1,1,1,1),这个时候对应最大值的数组为((9,5,5,8),(9,6,2,8)).然后再拿(9,5,5,8)和a[i][2][k]对应项来比较,即(9,5,5,8)和(-3,7,-9,1)来比较,则这个时候的索引值变为(1,2,0,1),同理,对于a[1][2][k]相比较,得出的索引变为(1,2,2,1)