Numpy 의 Axis 옵션에 대한 정리.

개요

쉬운 듯 하면서... 보면볼수록 헛갈린다. 기왕 정리하는 김에 포스팅하도록 한다... (쓰면서도 헛갈림...)

배열 수준별로 테스트해보자

2차원 배열에서

# 2차원 배열에서 axis 사용
import numpy as np
a = np.array([[10, 20, 30],
                 [15,7,55],
                 [5,33,12]])
print(np.max(a, axis=0)) # [15 33 55] # 열 기준 (위아래로 큰 것들)
print(np.max(a, axis=1)) # [30 55 33] # 행 기준 (옆으로 큰 것만 추림)

3차원 배열에서

import numpy as np
arr = [[[30, 15, 11],
        [27, 35, 23],
        [ 6,  1,  8],
        [17, 24, 32]],

       [[ 3,  4, 36],
        [34,  2, 19],
        [20, 16,  5],
        [22, 12,  7]],

       [[25, 29, 28],
        [14, 13, 21],
        [33, 10,  9],
        [18, 26, 31]]]

print(np.max(arr, axis=0)) # 모든 2차원 배열 중에서 동일한 위치의 값 중 큰 것으로 추림
'''
[[30 29 36]
 [34 35 23]
 [33 16  9]
 [22 26 32]]'''

print(np.max(arr, axis=1)) # 각각의 2차원 배열 '안'에서 열 기준으로 큰 값을 추림
'''
[[30 35 32]
 [34 16 36]
 [33 29 31]]'''

print(np.max(arr, axis=2)) # 각각의 1차원 '행' 안에서 큰 값을 추림.
'''
[[30 35  8 32]
 [36 34 20 22]
 [29 21 33 31]]'''

4차원 배열에서

import numpy as np
arr = [[[[71, 18],
         [34, 53],
         [69, 29]],

        [[63, 27],
         [12, 54],
         [58, 59]],

        [[24, 37],
         [64,  7],
         [33,  8]],

        [[22, 60],
         [28, 72],
         [19,  9]]],


       [[[43, 30],
         [23,  3],
         [61, 56]],

        [[ 1, 51],
         [46, 20],
         [10, 49]],

        [[66, 32],
         [26, 47],
         [17, 25]],

        [[41, 39],
         [35, 11],
         [67,  4]]],


       [[[50, 65],
         [55, 48],
         [52, 70]],

        [[44, 57],
         [40, 36],
         [16, 38]],

        [[15, 21],
         [31, 68],
         [ 5,  2]],

        [[13, 14],
         [ 6, 62],
         [42, 45]]]]

print(np.max(arr, axis=0)) # 
'''
[[[71 65]
  [55 53]
  [69 70]]

 [[63 57]
  [46 54]
  [58 59]]

 [[66 37]
  [64 68]
  [33 25]]

 [[41 60]
  [35 72]
  [67 45]]]'''

print(np.max(arr, axis=1)) # 
'''
[[[71 60]
  [64 72]
  [69 59]]

 [[66 51]
  [46 47]
  [67 56]]

 [[50 65]
  [55 68]
  [52 70]]]'''

print(np.max(arr, axis=2)) # 
'''
[[[71 53]
  [63 59]
  [64 37]
  [28 72]]

 [[61 56]
  [46 51]
  [66 47]
  [67 39]]

 [[55 70]
  [44 57]
  [31 68]
  [42 62]]]'''

print(np.max(arr, axis=3)) # 
'''
[[[71 53 69]
  [63 54 59]
  [37 64 33]
  [60 72 19]]

 [[43 23 61]
  [51 46 49]
  [66 47 25]
  [41 35 67]]

 [[65 55 70]
  [57 40 38]
  [21 68  5]
  [14 62 45]]]'''

음... 타이핑 해보고. 정리를 해보자면 다음과 같은 예상을 해볼 수 있다.

속성값 별

axis = 0

'가장 큰 단위'에서(즉, '입력값차원 - 1차원'끼리), '동일한 위치'에 있는 값들을 비교해서 큰 것만 추린다.

2차원 배열에서

• 1차원 배열들이 있는데, 각각 비교해서 동일한 위치에 있는 것 중 가장 큰 것만 추린다.
• => 결과적으로 열 단위로 비교한 셈이 됨.
• 예를 들어) $i_{?1}$ 끼리 비교해서 $r_{1}$ 에 넣는 식이다.
• $i_{?a} => r_a$

3차원 배열에서

• 각 2차원 배열들이 있는데, 동일한 위치에 있는 것 끼리 비교해서 큰 것만 추린다.
• 예를 들어) $i_{?11}$ 끼리 비교해서 $r_{11}$에 넣는 식이다.
• $i_{?ab} => r_{ab}$

4차원 배열에서

• 각 3차원 배열들이 있는데, 동일한 위치에 있는 것끼리 비교해서 큰 것만 추린다.
• 예를 들어) $i_{?111}$ 끼리 비교해서 $r_{111}$에 넣는 식이다.
• $i_{?abc} => r_{abc}$

axis = 1

입력값차원 보다 2단계 낮은 단위에서 비교를 한다.

2차원 배열에서

• 예시) $i_{1?}$끼리 비교해서 $r_1$에 넣는 식.
• $i_{a?} => r_a$

3차원 배열에서

• 예시) $i_{1?1}$끼리 비교해서 $r_{11}$에 넣는 식.
• $i_{a?b} => r_{ab}$

4차원 배열에서

• 예시) $i_{1?23}$끼리 비교해서 $r_{123}$에 넣는 식.
• $i_{a?bc} => r_{abc}$