参考：Python：一文让你彻底理解numpy中axis=-1/0/1/2… [实例讲解：np.argmax(axis= -1 0 1 2) np.sum(aixs= -1 0 1 2)]

0. 前置知识

0.1 axis

axis翻译过来就是轴的意思。

numpy数组中：

• 一维数组拥有一个轴：axis=0；
• 二维数组拥有两个轴：axis=0，axis=1；
• 三维数组拥有三个轴：axis=0，axis=1，axis=2。
• 四维数组拥有三个轴：axis=0，axis=1，axis=2，axis=3。

0.2 数组维度

可以从左至右计算数组的方括号数目，一个方括号是一维数组，两个方括号是二维数组，三个方括号是三维数组。
如： [1, 2, 3]是一维数组、[[1, 2, 3], [4, 5, 6]]是二维数组、[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]] 是三维数组。

0.3 axis(轴)与数组括号的对应关系

numpy数组都有[]标记，其对应关系：axis=0对应最外层的[]，axis=1对应第二外层的[]，…，axis=n对应第n外层的[]。以三维数组为例，两者关系如下表所示：

1. 如何理解对numpy数组的axis(轴)的操作

这里使用了博主西北种田文的方法“括号最大块法”。

博客链接为：Python：一文让你彻底理解numpy中axis=-1/0/1/2… [实例讲解：np.argmax(axis= -1 0 1 2) np.sum(aixs= -1 0 1 2)]

括号最大块法有且仅有两步：

• 第一步：由axis = value，找对应[]里的最大单位块。（np.sum()拆掉此层[]，np.argmax()不拆此层[]）

• 第二步：对单位块进行计算，这里又分为两种情况：

  • 当单位块是数值时，直接计算
  • 当单位块是数组时，对应下标元素进行计算

接下来对上述方法进行补充说明：

首先，最大单位块就是某层[]里包裹的最大结构块。比如：

• [1，2，3]：[]里最大的单位块是数值 1 2 3。
• [[1，2]，[3，4]]：最外层[]里最大单位块是[1，2] 和 [3，4]，第二层[]里最大单位块是1，2 和 3，4。
• [[[1，2]，[3，4]]，[[5，6]，[7，8]]]：最外层[]里最大单位块是[[1，2]，[3，4]]和[[5，6]，[7，8]]，第二层[]里最大单位块是[1，2]和[3，4] 还有 [5，6]和[7，8]，第三层[]里最大单位块是1，2 和 3，4 和 5，6 和 7，8。

其次，最大单位块是数组时，对应下标元素的计算方法为：

• 对于numpy二维数组[[1，2]，[3，4]]。
  axis=0，最外层[]，有一对，其里包含两个最大块[1，2]、[3，4]，这两个块1和3、2和4即为对应。
  axis=1，第二层[]，有两对，两个[]都为数值，直接计算。
• 对于numpy三维数组[[[1, 2],[3, 4]], [[5, 6],[7, 8]]]。
  axis=0，最外层[]，有一对，其里包含两个最大块[[1, 2],[3, 4]]、 [[5, 6],[7, 8]]，这两个块1和5、2和6、3和7、4和8即为对应。
  axis=1，第二层[]，有两对，第一个[]最大块为：[1, 2]、[3, 4]，其中1和3、2和4对应；第二个[]最大块为：[5, 6]，[7, 8]，其中5和7、6和8对应。
  axis=2，第三层[]，有四对，4个[]内都是数值，直接计算。

2. 实例

2.1 实例1：np.sum(axis=-1/0/1/2)

一维数组

axis=0

>>> import numpy as np
>>> arr = np.array([1, 2, 3])
>>> arr.sum(axis = 0)
6

第一步：axis=0对应最外层[]，其内最大单位块为：1，2，3，并去掉[]
第二步：单位块是数值，直接计算：1+2+3=6

axis=1

>>> arr = np.array([1, 2, 3])
>>> arr.sum(axis = 1)  # 越界使用，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "D:\Anaconda3\lib\site-packages\numpy\core\_methods.py", line 38, in _sum
    return umr_sum(a, axis, dtype, out, keepdims, initial, where)
numpy.AxisError: axis 1 is out of bounds for array of dimension 1

由此可知，使用axis时，不要越界，即：N维数组，最大能使用axis=N-1

二维数组

axis=0

>>> arr = np.array([[1, 2], [3, 4]])
>>> arr.sum(axis = 0)
array([4, 6])

第一步：axis=0对应最外层[]，其内最大单位块为：[1，2] 和 [3，4]，并去掉最外层[]
第二步：单位块是数组，两者对应下标元素进行计算，即：[1+3，2+4]=[4，6]

axis=1

>>> arr = np.array([[1, 2], [3, 4]])
>>> arr.sum(axis = 1)
array([3, 7])

第一步：axis=1对应第二层[]，其内最大单位块为：第一[]内： 1，2；第二[]内： 3，4，并去掉第二层[]
第二步：单位块是数值，直接进行计算，即：[1+2，3+4]=[3，7]

三维数组

axis=0

>>> arr = np.array([[[1, 2],[3, 4]], [[5, 6],[7, 8]]])
>>> arr
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])
>>> arr.sum(axis=0)
array([[ 6,  8],
       [10, 12]])

第一步：axis=0对应最外层[]，其内最大单位块为：[[1, 2],[3, 4]] 和 [[5, 6],[7, 8]]，并去掉最外层[]
第二步：单位块是数组，两者对应下标元素进行计算，即：[[1, 2]，[3, 4]] + [[5, 6],[7, 8]] = [[1+5，2+6]，[3+7，4+8]] = [[6，8]， [10，12]]

axis=1

>>> arr = np.array([[[1, 2],[3, 4]], [[5, 6],[7, 8]]])
>>> arr.sum(axis=1)
array([[ 4,  6],
       [12, 14]])

第一步：axis=1对应第二层[]，其内最大单位块为：第一个[]： [1, 2]和[3, 4]；第二个[]： [5, 6]和[7, 8]，并去掉第二层[]
第二步：单位块是数组，两者对应下标元素进行计算，即：第一个[]内：[1+3，2+4]，第二个[]内：[5+7，6+8]，即：[[1+3，2+4]，[5+7， 6+8]] = [[4，6]，[12，14]]

axis=2

>>> arr = np.array([[[1, 2],[3, 4]], [[5, 6],[7, 8]]])
>>> arr.sum(axis=2)
array([[ 3,  7],
       [11, 15]])

第一步：axis=1对应第三层[]，其内最大单位块为：第一个[]：1，2；第二个[]：3，4；第三个[]：5，6；第四个[]：7，8，并去掉第三层[]
第二步：单位块是数值，直接进行计算，即：[[1+2，3+4]，[5+6，7+8]] = [[3，7]，[11，15]]

axis=-1

>>> arr = np.array([[[1, 2],[3, 4]], [[5, 6],[7, 8]]])
>>> arr.sum(axis=-1)
array([[ 3,  7],
       [11, 15]])

axis=-1，表示在当前数组最后一维度操作，三维数组中axis=0/1/2，那么axis=-1即等价于axis=2，所以其结果与axis=2相同！

2.2 实例2：np.argmax(axis=-1/0/1/2)

np.argmax()：取数组中元素最大值的下标值
np.argmax()中axis=0/1/2…原理与np.sum()中类似，只是不用“拆括号”了！

一维数组

>>> import numpy as np
>>> arr = np.array([3, 4, 6, 9, 1, 2])
>>> print(np.argmax(arr)) # 默认axis=0
3
>>> print(np.argmax(arr, axis=0))
3

二维数组

axis=0

>>> arr = np.array([[3, 6, 6, 2], [4, 7, 11, 2], [5, 9, 1, 3]])
>>> arr
array([[ 3,  6,  6,  2],
       [ 4,  7, 11,  2],
       [ 5,  9,  1,  3]])
>>> np.argmax(arr, axis=0)
array([2, 2, 1, 2], dtype=int64)
>>> print(np.argmax(arr, axis=0))
[2 2 1 2]

第一步：axis=0对应最外层[]，其内最大单位块为：[ 3, 6, 6, 2]、 [ 4, 7, 11, 2]和[ 5, 9, 1, 3]
第二步：单位块是数组，两者对应下标元素进行计算，即：argmax([3，4，5])、argmax([6，7，9])、argmax([6，11，1])、argmax([2，2，3])，得到4个最大值索引值：2、2、1、2，得到索引值数组：[2 2 1 2]

axis=1

>>> arr = np.array([[3, 6, 6, 2], [4, 7, 11, 2], [5, 9, 1, 3]])
>>> arr
array([[ 3,  6,  6,  2],
       [ 4,  7, 11,  2],
       [ 5,  9,  1,  3]])
>>> print(np.argmax(arr, axis=1))
[1 2 1]       

第一步：axis=1对应第二层[]，其内最大单位块为：3, 6, 6, 2 和 4, 7, 11, 2 和 5, 9, 1, 3
第二步：单位块是数值，直接进行计算，即：argmax([3，6，6，2])、argmax([4，7，11，2])、argmax([5，9，1，3])，得到3个最大值索引值：1、2、1，得到索引数组：[1 2 1]

三维数组

axis=0

>>> arr = np.array([[[1, 5, 5, 2], [9, -6, 2, 8], [-3, 7, -9, 1]], [[-1, 7, -5, 2], [9, 6, 2, 8], [3, 7, 9, 1]], [[21, 6, -5, 2], [9, 36, 2, 8], [2, 7, 66, 1]]])
>>> arr
array([[[ 1,  5,  5,  2],
        [ 9, -6,  2,  8],
        [-3,  7, -9,  1]],

       [[-1,  7, -5,  2],
        [ 9,  6,  2,  8],
        [ 3,  7,  9,  1]],

       [[21,  6, -5,  2],
        [ 9, 36,  2,  8],
        [ 2,  7, 66,  1]]])
>>> print(np.argmax(arr, axis=0))
[[2 1 0 0]
 [0 2 0 0]
 [1 0 2 0]]

第一步：axis=0对应最外层[]，其内最大单位块为：

第二步：单位块是数组，三者对应下标元素进行计算，如图：

即：argmax([1，-1，21)、argmax([5，7，6])、argmax([5，-5，-5])、argmax([2，2，2])、argmax([9，9，9])、argmax([-6，6，36])…以此类推，得到索引值数组：

axis=1

>>> arr
array([[[ 1,  5,  5,  2],
        [ 9, -6,  2,  8],
        [-3,  7, -9,  1]],

       [[-1,  7, -5,  2],
        [ 9,  6,  2,  8],
        [ 3,  7,  9,  1]],

       [[21,  6, -5,  2],
        [ 9, 36,  2,  8],
        [ 2,  7, 66,  1]]])
>>> print(np.argmax(arr, axis=1))
[[1 2 0 1]
 [1 0 2 1]
 [0 1 2 1]]

第一步：axis=1对应第二层[]，其内最大单位块为：
第一个[]内最大单位块：

第二个[]内最大单位块：

第三个[]内最大单位块：

第二步：各[]内单位块是数组且都为三块，三者对应下标元素进行计算，即：
第一个[]内，三块对应下标，如图：

计算：argmax([1，9，-3)、argmax([5，-6，7])、argmax([5，2，-9])、argmax(2，8，1)
以此类推：第二个[]、第三个[]，得到索引值数组：

axis=2

>>> arr
array([[[ 1,  5,  5,  2],
        [ 9, -6,  2,  8],
        [-3,  7, -9,  1]],

       [[-1,  7, -5,  2],
        [ 9,  6,  2,  8],
        [ 3,  7,  9,  1]],

       [[21,  6, -5,  2],
        [ 9, 36,  2,  8],
        [ 2,  7, 66,  1]]])
>>> print(np.argmax(arr, axis=2))
[[1 0 1]
 [1 0 2]
 [0 1 2]]

第一步：axis=2对应第三层[]，其内最大单位块为：
1，5，5，2
9，-6，2，8
-3，7，-9，1

-1，7，-5，2
9，6，2，8
3，7，9，1

21，6，-5，2
9，36，2，8
2，7，66，1

第二步：单位块是数值，直接进行计算，即：
argmax([1，5，5，2])
argmax([9，-6，2，8])
argmax([-3，7，-9，1])
argmax([-1，7，-5，2])
…
以此类推，得到索引数组：

axis=-1

>>> print(np.argmax(arr, axis=-1))
[[1 0 1]
 [1 0 2]
 [0 1 2]]

axis=-1，表示在当前数组最后一维度操作，三维数组中axis=0/1/2，那么axis=-1即等价于axis=2，所以其结果与axis=2相同！

二维数组情形

例1

mu = np.mean(features,axis=0)

features为M×N, 那么mu为(N,)或记1×N

例2

X_input = np.concatenate((features,intercept_feature),axis=1)

features为M×N，那么X_input为M ×（N+1）

例3

>>> a = np.array([[1, 2], [3, 4]])
>>> np.mean(a)
2.5
>>> np.mean(a, axis=0)
array([ 2.,  3.])
>>> np.mean(a, axis=1)
array([ 1.5,  3.5])

点评：矩阵记法M×N，M为行数，N为列数。

三维数组情形

例4

A = np.arange(8).reshape((2,2,2))

A:

array([[[0, 1],
        [2, 3]],

       [[4, 5],
        [6, 7]]])

mu0 = np.mean(A,axis=0)

mu0:

array([[2., 3.],
       [4., 5.]])

mu1 = np.mean(A,axis=1)

mu1:

array([[1., 2.],
       [5., 6.]])

mu2= np.mean(A,axis=2)

mu2:

array([[0.5, 2.5],
       [4.5, 6.5]])

点评：三维数组可以理解为两个二维平面平行放置。

B=np.arange(50).reshape((2,5,5))

B:

array([[[ 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]]])

B[0]:

array([[ 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]])

C=np.arange(50).reshape((5,5,2))

C:

array([[[ 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]]])

例5

A = np.arange(8).reshape((2,2,2))

A:

array([[[0, 1],
        [2, 3]],

       [[4, 5],
        [6, 7]]])

filter_kernel_flipped=np.rot90(A, 1, (1,2))

filter_kernel_flipped:

array([[[1, 3],
        [0, 2]],

       [[5, 7],
        [4, 6]]])

此例np.rot90()函数为axis1和axis2确定的平面内旋转一次。

更多数学原理小文请关注公众号：未名方略

tensorflow中的norm函数作用是用来求L1_norm范数和Eukl_norm范数。 本篇文章主要目的是讲解axis的含义，所以默认都是用L1_norm范数，方便理解。

首先，来看一下2维的情况

创建一个 2×3 的常量

a = tf.constant(range(6), shape = [2,3])

tf.norm(a,ord=1,axis=0)

axis=0，可以理解为将shape中的第0个索引盖住，只对其他索引进行操作
此处，相当于只对列进行操作，即每一列都求范数。
当axis=1时，同理。
如图：

接下来，在看3维的情况

创建一个 2×3×4 的常量

a = tf.constant(range(24), shape = [2,3,4])

同2维一样的理解：
若axis=0，则将shape中的第0个索引无视，对其他索引进行操作。
此处为 对所有的 3×4 矩阵进行求范数，也就是把所有的3×4的矩阵进行相加。
如图：

axis=1，表示将shape中的第1个索引无视，只对第0个和第2个索引进行操作。
此处可以理解为：
将所有 3×4 矩阵中的列进行求范数，也就是说，对2个 3×4 列矩阵中的所有列进行求范数，而无视行的概念。
如图：

axis=2, 则表示无视列概念，对所有的行进行操作。
如图：

个人理解，有误请指正。