彻底理解numpy中的axis

时下流行人工智能，python成为人工智能最好的处理语言，这与python中的科学计算模块numpy是分不开的。numpy相信大都数人都知道。而在numpy中，有很多的函数都涉及到axis，numpy中的轴axis是很重要的，许多numpy的操作根据axis的取值不同，作出的操作也不相同。可以说，axis让numpy的多维数组变的更加灵活，但也让numpy变得越发难以理解。因此，弄清楚axis的作用显得尤为重要。

• 为什么要设计axis这个东西呢？

numpy是个多维数组，多维数组运算需要指定到底对哪一维操作，因此axis就是用来指定需要操作的维数。 

•  简单示例

先来看看一个二维数组

>>> import numpy as np  
>>> np_data = np.array([[1,2,3],[4,5,6],[1,3,5],[2,4,6]])
>>> np_data
array([[1, 2, 3],                                                                                                                          
       [4, 5, 6],                                                                                                              
       [1, 3, 5],                                                                                                              
       [2, 4, 6]])

假设 这个数组代表了样本数据的特征，其中每一行代表一个样本的三个特征，每一列是不同样本的特征。如果在分析样本的过程中需要对每个样本的三个特征求和，该如何处理？

>>> np.sum(np_data,axis=1)
array([ 6, 15,  9, 12])

那如果想求每种特征的最小值，该如何处理？

>>> np.min(np_data, axis=0)
array([1, 2, 3])

又如果想得知所有样本所有特征的平均值呢？

>>> np.average(np_data)
3.5

• 重点

由此可以看出：（划重点）通过不同的axis，numpy会沿着不同的方向进行操作：如果不设置，那么对所有的元素操作；如果axis=0，则沿着纵轴进行操作；axis=1，则沿着横轴进行操作。但这只是简单的二位数组，如果是多维的呢？可以总结为一句话：设axis=i，则numpy沿着第i个下标变化的方向进行操作。例如刚刚的例子，可以将表示为：

data =[[a00, a01],
       [a10, a11]]

所以axis=0时，沿着第0个下标变化的方向进行操作，也就是a00->a10, a01->a11，也就是纵坐标的方向，axis=1时也类似。

• 多维数组验证

下面我们举一个四维的求sum的例子来验证一下：

>>> np_data = np.random.randint(0, 6, [4,2,3,4])
>>> np_data
array([[[[3, 5, 5, 0],                                                                                                               
         [0, 1, 2, 4],                                                                                                           
         [0, 5, 0, 5]],    # D0000  ->   D0023
                                                                                                                                                                                                                                
         [[5, 5, 0, 0],                                                                                                           
          [2, 1, 5, 0],                                                                                                           
          [1, 0, 0, 1]]],  # D0100  ->   D0123
                                                                                                                                                                                                                                                                                                                                                     
       [[[0, 5, 1, 2],                                                                                                           
         [4, 4, 2, 2],                                                                                                           
         [3, 5, 0, 1]],    # D1000  ->   D1023                                                                                                                                                                                                                        
        
        [[5, 1, 2, 1],                                                                                                           
         [2, 2, 3, 5],                                                                                                           
         [5, 3, 3, 3]]],   # D1100  ->   D1123                                                                                                                                                                                                                                                                                                                                                  

       [[[2, 4, 1, 4],                                                                                                           
         [1, 4, 1, 4],                                                                                                           
         [4, 5, 0, 2]],    # D2000  ->   D2023                                                                                                                                                                                                                         
        
        [[2, 5, 5, 1],                                                                                                           
         [5, 3, 0, 2],                                                                                                           
         [4, 0, 1, 3]]],   # D2100  ->   D2123                                                                                                                                                                                                                                                                                                                                                  

       [[[1, 3, 4, 5],                                                                                                           
         [0, 2, 5, 4],                                                                                                           
         [2, 3, 5, 3]],    # D3000  ->   D3023                                                                                                                                                                                                                           
       
        [[2, 2, 2, 2],                                                                                                           
         [3, 2, 1, 3],                                                                                                           
         [0, 3, 0, 1]]]])  # D3100  ->   D3123

• 当axis=0时，numpy验证第0维的方向来求和，也就是第一个元素值=D0000+D1000+D2000+D3000=3+0+2+1=6,第二个元素=D0001+D1001+D2001+D3001=5+5+4+3=17，同理可得最后的结果如下：

>>> np_data.sum(axis=0)
array([[[ 6, 17, 11, 11],                                                                                                       
        [ 5, 11, 10, 14],                                                                                                       
        [ 9, 18,  5, 11]],                                                                                                                                                                                                                             
      
      [[14, 13,  9,  4],                                                                                                       
       [12,  8,  9, 10],                                                                                                       
       [10,  6,  4,  8]]])

• 当axis=3时，numpy验证第3维的方向来求和，也就是第一个元素值=D0000+D0001+D0002+D0003=3+5+5+0=13,第二个元素=D0010+D0011+D0012+D0013=0+1+2+4=7，同理可得最后的结果如下：

>>> data.sum(axis=3)
array([[[13,  7, 10],                                                                                                               
        [10,  8,  2]],                                                                                                                                                                                                                                 
    
       [[ 8, 12,  9],                                                                                                           
        [ 9, 12, 14]],                                                                                                                                                                                                                                 

       [[11, 10, 11],                                                                                                           
        [13, 10,  8]],                                                                                                                                                                                                                                 

       [[13, 11, 13],                                                                                                           
        [ 8,  9,  4]]])

 

• 使用axis的相关函数

在numpy中，使用的axis的地方非常多，处理上文已经提到的average、max、min、sum，比较常见的还有sort和prod，下面分别举几个例子看一下：

• sort

>>> np_data = np.random.randint(0, 4, [2,2,3])
>>> np_data
array([[[2, 0, 2],                                                                                                              
        [1, 1, 1]],                                                                                                                                                                                                                                    

       [[3, 2, 1],                                                                                                              
        [2, 2, 0]]])
>>> np.sort(np_data)  ## 默认对最大的axis进行排序，这里即是axis=2
array([[[0, 2, 2],                                                                                                              
        [1, 1, 1]],                                                                                                                                                                                                                                    

       [[1, 2, 3],                                                                                                              
        [0, 2, 2]]])
>>> np.sort(np_data, axis=0) #沿着第0维进行排序，原先的D000->D100
array([[[2, 0, 1],                                                                                                              
        [1, 1, 0]],                                                                                                                                                                                                                                    

       [[3, 2, 2],                                                                                                              
        [2, 2, 1]]])
>>> np.sort(np_data, axis=1)  # 沿着第1维进行排序
array([[[1, 0, 1],                                                                                                              
        [2, 1, 2]],                                                                                                                                                                                                                                    

       [[2, 2, 0],                                                                                                              
        [3, 2, 1]]])
>>> np.sort(np_data, axis=2)  # 沿着第2维进行排序（和默认对最大的axis进行排序一样结果）
array([[[0, 2, 2],                                                                                                              
        [1, 1, 1]],                                                                                                                                                                                                                                    

       [[1, 2, 3],                                                                                                              
        [0, 2, 2]]]) 
>>> np.sort(np_data, axis=None)  # 对全部数据进行排序
array([0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3])

• prod(即product，乘积)

 >>> np.prod([[1.,2.],[3.,4.]])
 24.0

 >>> np.prod([[1.,2.],[3.,4.]], axis=1)
 array([  2.,  12.])

 >>> np.prod([[1.,2.],[3.,4.]], axis=0)
 array([ 3.,  8.])

简要概括axis的用法是：假设axis = i，则numpy沿着第 i 个下标变化的方向进行操作

相信通过上面的讲解与例子，你应该对axis有了比较清楚的了解。只有真正理解axis的原理，才能对numpy操作游刃有余。