Numpy part II

Numpy part II¶

---

Handling shape¶

reshape¶

• Array의 shape의 크기를 변경함, element의 갯수는 동일

In [1]:

import numpy as np

In [2]:

test_matrix = [[1, 2, 3, 4], [1, 2, 5, 8]]
np.array(test_matrix).shape

Out[2]:

(2, 4)

In [3]:

np.array(test_matrix).reshape(8,)

Out[3]:

array([1, 2, 3, 4, 1, 2, 5, 8])

In [4]:

np.array(test_matrix).reshape(4, 2)

Out[4]:

array([[1, 2],
       [3, 4],
       [1, 2],
       [5, 8]])

In [5]:

np.array(test_matrix).reshape(2, 2, 2)

Out[5]:

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

       [[1, 2],
        [5, 8]]])

In [6]:

print(np.array(test_matrix).reshape(2, -1))
print(np.array(test_matrix).reshape(2, -1).shape)

[[1 2 3 4]
 [1 2 5 8]]
(2, 4)

• -1: size를 기반으로 크기를 선정

flatten¶

• 다차원 array를 1차원 array로 변환

In [7]:

test_matrix = [[[1, 2, 3, 4], [1, 2, 5, 8]], [[1, 2, 3, 4], [1, 2, 5, 8]]]
mat=np.array(test_matrix)
mat

Out[7]:

array([[[1, 2, 3, 4],
        [1, 2, 5, 8]],

       [[1, 2, 3, 4],
        [1, 2, 5, 8]]])

In [8]:

mat.size

Out[8]:

16

In [9]:

mat.flatten()

Out[9]:

array([1, 2, 3, 4, 1, 2, 5, 8, 1, 2, 3, 4, 1, 2, 5, 8])

indexing & slicing¶

indexing¶

• list와 달리 이차원 배열에서 [0,0] 표기법을 제공한다
• matrix일 경우 앞은 row뒤는 column을 의미한다

In [10]:

test_example = np.array([[1, 2, 3], [4.5, 5, 6]], int)
test_example

Out[10]:

array([[1, 2, 3],
       [4, 5, 6]])

In [11]:

print(test_example[0][2])
print(test_example[0,2])

3
3

In [12]:

test_example[0, 0] = 10  # Matrix 0,0 에 12 할당
test_example

Out[12]:

array([[10,  2,  3],
       [ 4,  5,  6]])

slicing¶

• list와 달리 행과 열 부분을 나눠서 slicing이 가능하다
• matrix의 부분 집합을 추출할 때 유용하다

In [13]:

test_example = np.array([[1, 2, 5, 8], [1, 2, 5, 8], [1, 2, 5, 8], [1, 2, 5, 8]], int)
test_example

Out[13]:

array([[1, 2, 5, 8],
       [1, 2, 5, 8],
       [1, 2, 5, 8],
       [1, 2, 5, 8]])

In [14]:

test_example[:2,:]  # 전체 col의 2행 까지

Out[14]:

array([[1, 2, 5, 8],
       [1, 2, 5, 8]])

In [15]:

test_example[:, 2:]

Out[15]:

array([[5, 8],
       [5, 8],
       [5, 8],
       [5, 8]])

In [16]:

test_example[1:3]  # 1 row ~ 2row의 전체

Out[16]:

array([[1, 2, 5, 8],
       [1, 2, 5, 8]])

• ,없이 하나의 값만 쓰게 되면 기본적으로 행(row)에 대한 처리를 한다

In [17]:

test_example = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], int)
test_example

Out[17]:

array([[ 1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10]])

In [18]:

test_example[1,1:3]  # 1row 의 1열 ~2열

Out[18]:

array([7, 8])

In [19]:

arr = np.arange(15).reshape(3, -1)
arr

Out[19]:

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

In [21]:

arr[:, -1]

Out[21]:

array([ 4,  9, 14])

• 여기서 -1은 마지막을 의미한다

In [22]:

arr[:,::2]

Out[22]:

array([[ 0,  2,  4],
       [ 5,  7,  9],
       [10, 12, 14]])

In [23]:

arr[::2,::3]

Out[23]:

array([[ 0,  3],
       [10, 13]])

• slicing: [start:end:step]으로 표현해서 step도 표현 가능하다

creation function¶

arange¶

• array의 범위를 지정하여, 값의 list를 생성하는 명령어

In [24]:

# integer로 0부터 29까지 배열추출
np.arange(30)

Out[24]:

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])

In [25]:

np.arange(0, 10, 0.5)

Out[25]:

array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. ,
       6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])

• 여기서 step을 소수점으로도 표현이 가능하다

In [26]:

np.arange(30).reshape(5, 6)

Out[26]:

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]])

zeros¶

• 0으로 가득찬 ndarray 생성

In [27]:

# 10 - zero vector 생성
np.zeros(shape=(10,),dtype=np.int8)

Out[27]:

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int8)

In [28]:

np.zeros((2, 5))  # 2 by 5 - zero matrix 생성

Out[28]:

array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

ones¶

• 1로 가득찬 ndarray 생성

In [29]:

np.ones(shape=(10,), dtype=np.int8)

Out[29]:

array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int8)

In [30]:

np.ones((3, 4))

Out[30]:

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

empty¶

• shape만 주어지고 비어있는 ndarray생성(memory initialization 이 되지 않음)

In [31]:

np.empty(shape=(10,), dtype=np.int8)

Out[31]:

array([-80,  95,  95,  15, -39,   1,   0,   0,   0,   0], dtype=int8)

In [32]:

np.empty((10, 5))

Out[32]:

array([[             nan, -8.14846384e-311,  5.03946959e-321,
         4.94065646e-324,  2.92486862e-321],
       [ 2.03060980e-321,  4.26872718e-321,  2.03060980e-321,
         4.30825243e-321,  2.03060980e-321],
       [ 4.16991405e-321,  2.03060980e-321,  4.32801506e-321,
         2.03060980e-321,  2.70747974e-321],
       [-8.89752835e-311,  2.27270197e-321,  2.03060980e-321,
         5.03946959e-321,  2.03060980e-321],
       [ 5.27662110e-321,  2.44549915e-056,  5.69163624e-321,
        -2.37875728e-311,  4.52564132e-321],
       [ 1.03151095e+166,  2.27270197e-321,  1.97626258e-323,
         5.69163624e-321, -9.23589246e-311],
       [ 5.03946959e-321,  1.97626258e-323,  4.30825243e-321,
         3.68415056e+180,  4.16991405e-321],
       [ 1.36639737e+069,  4.32801506e-321,  4.85464539e-028,
         2.70747974e-321,  1.11737403e+021],
       [ 2.27270197e-321,  2.37835288e+180,  5.03946959e-321,
        -9.97434463e-311,  1.00383836e-311],
       [ 3.16202013e-322,  0.00000000e+000,  0.00000000e+000,
         0.00000000e+000,  1.28075714e+161]])

• 공간만 잡아주고 값은 초기화 되어있지 않음

sometihing_like¶

• 기존 ndarray의 shape크기 만큼 1,0 또는 empty array를 반환

In [33]:

test_matrix=np.arange(30).reshape(5,6)
test_matrix

Out[33]:

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]])

In [34]:

np.ones_like(test_matrix)

Out[34]:

array([[1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1]])

In [35]:

np.zeros_like(test_matrix)

Out[35]:

array([[0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0]])

In [36]:

np.empty_like(test_matrix)

Out[36]:

array([[0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0]])

identity¶

• 단위 행렬(i행렬)을 생성함

In [37]:

np.identity(n=3, dtype=np.int8)

Out[37]:

array([[1, 0, 0],
       [0, 1, 0],
       [0, 0, 1]], dtype=int8)

• n → number of rows

In [38]:

np.identity(5)

Out[38]:

array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

eye¶

• 대각선이 1인 행렬, k값의 시작 index의 변경이 가능

In [39]:

np.eye(3)

Out[39]:

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

In [40]:

np.eye(N=3, M=5, dtype=np.int8)

Out[40]:

array([[1, 0, 0, 0, 0],
       [0, 1, 0, 0, 0],
       [0, 0, 1, 0, 0]], dtype=int8)

In [41]:

np.eye(3, 5, k=2)

Out[41]:

array([[0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])

diag¶

In [42]:

matrix = np.arange(9).reshape(3, 3)
matrix

Out[42]:

array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

In [43]:

np.diag(matrix)

Out[43]:

array([0, 4, 8])

In [44]:

np.diag(matrix,k=1)

Out[44]:

array([1, 5])

• k → start index

In [45]:

np.diag(matrix, k=-1)

Out[45]:

array([3, 7])

random sampling¶

• 데이터 분포에 따른 sampling으로 array를 생성

In [46]:

np.random.uniform(0, 1, 10).reshape(2, 5) # 균등 분포

Out[46]:

array([[0.85783221, 0.31723011, 0.33493637, 0.62314927, 0.42895495],
       [0.71321811, 0.80752715, 0.53193699, 0.28509201, 0.17922008]])

In [47]:

np.random.normal(0, 1, 10).reshape(2, 5)   # 정규 분포

Out[47]:

array([[-1.11180851, -0.64689831, -0.10100984,  0.56420641,  1.28965139],
       [-1.38193924, -0.50887726, -1.27123305, -0.23808343,  0.17748383]])

In [48]:

np.random.exponential(scale=2,size=10)

Out[48]:

array([1.28276532, 2.3947798 , 0.0192522 , 0.44135467, 3.56546947,
       2.3323017 , 0.87920765, 0.46068327, 7.4869394 , 3.76781449])

operation functions¶

sum¶

• ndarray의 element들 간의 합을 구함, list의 sum기능과 동일

In [49]:

test_array = np.arange(1, 11)
test_array

Out[49]:

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])

In [50]:

test_array.sum()

Out[50]:

55

axis¶

• 모든 operation function을 실행할 때 기준이 되는 dimension축

In [51]:

# 2차원 일때,
test_array = np.arange(1, 13).reshape(3, 4)
test_array

Out[51]:

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

In [52]:

test_array.sum(axis=1), test_array.sum(axis=0)

Out[52]:

(array([10, 26, 42]), array([15, 18, 21, 24]))

In [53]:

# 3차원 일때,
third_order_tensor = np.array([test_array, test_array, test_array])
print(third_order_tensor.shape)
third_order_tensor

(3, 3, 4)

Out[53]:

array([[[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12]],

       [[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12]],

       [[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12]]])

In [54]:

third_order_tensor.sum(axis=2)

Out[54]:

array([[10, 26, 42],
       [10, 26, 42],
       [10, 26, 42]])

In [55]:

third_order_tensor.sum(axis=1)

Out[55]:

array([[15, 18, 21, 24],
       [15, 18, 21, 24],
       [15, 18, 21, 24]])

In [56]:

third_order_tensor.sum(axis=0)

Out[56]:

array([[ 3,  6,  9, 12],
       [15, 18, 21, 24],
       [27, 30, 33, 36]])

mean & std¶

• ndarray의 element들 간의 평균 또는 표준편차를 반환

In [57]:

test_array = np.arange(1, 13).reshape(3, 4)
test_array

Out[57]:

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12]])

In [58]:

test_array.mean(),test_array.mean(axis=0)

Out[58]:

(6.5, array([5., 6., 7., 8.]))

In [59]:

test_array.std(), test_array.std(axis=1)

Out[59]:

(3.452052529534663, array([1.11803399, 1.11803399, 1.11803399]))

mathematical functions¶

• 그 외에도 다양한 수학 연산자를 제공함(np.something 호출)

In [60]:

np.exp(test_array), np.sqrt(test_array)

Out[60]:

(array([[2.71828183e+00, 7.38905610e+00, 2.00855369e+01, 5.45981500e+01],
        [1.48413159e+02, 4.03428793e+02, 1.09663316e+03, 2.98095799e+03],
        [8.10308393e+03, 2.20264658e+04, 5.98741417e+04, 1.62754791e+05]]),
 array([[1.        , 1.41421356, 1.73205081, 2.        ],
        [2.23606798, 2.44948974, 2.64575131, 2.82842712],
        [3.        , 3.16227766, 3.31662479, 3.46410162]]))

concatenate¶

• numpy array를 합치는(붙이는)함수

In [61]:

a = np.array([1, 2, 3])
b = np.array([2, 3, 4])
np.vstack((a, b))

Out[61]:

array([[1, 2, 3],
       [2, 3, 4]])

In [62]:

a = np.array([[1], [2], [3]])
b = np.array([[2], [3], [4]])
np.hstack((a, b))

Out[62]:

array([[1, 2],
       [2, 3],
       [3, 4]])

In [63]:

a = np.array([[1, 2, 3]])
b = np.array([[2, 3, 4]])
np.concatenate((a, b), axis=0)

Out[63]:

array([[1, 2, 3],
       [2, 3, 4]])

In [64]:

a = np.array([[1, 2, 3]])
b = np.array([[2, 3, 4]])
np.concatenate((a, b), axis=1)

Out[64]:

array([[1, 2, 3, 2, 3, 4]])

In [65]:

a = np.array([[1, 2], [3, 4]])
b = np.array([[5], [6]])
np.concatenate((a, b), axis=1)

Out[65]:

array([[1, 2, 5],
       [3, 4, 6]])

In [66]:

b = np.array([5, 6])
b = b[np.newaxis, :]
b

Out[66]:

array([[5, 6]])

• 위 [5,6]을 2D으로 만들어 줘야하는데 이러면 축이 하나가 더 필요하다
• 이럴때 np.newaxis를 사용해서 축을 하나 만들어 준다
• b.reshap(-1,2)와 같이해서 추가하는거와 같다

In [67]:

a = np.array([[1, 2], [3, 4]])
b = np.array([5, 6])
b = b[np.newaxis, :]
np.concatenate((a, b.T), axis=1)

Out[67]:

array([[1, 2, 5],
       [3, 4, 6]])

• np.T는 전치행렬을 만든다

array operations¶

• numpy는 array간의 기본적인 사칙 연산을 지원함

In [68]:

test_a = np.array([[1, 2, 3], [4, 5, 6]], float)

In [69]:

test_a + test_a  # Matrix + Matrix 연산

Out[69]:

array([[ 2.,  4.,  6.],
       [ 8., 10., 12.]])

In [70]:

test_a - test_a  # Matrix - Matrix 연산

Out[70]:

array([[0., 0., 0.],
       [0., 0., 0.]])

In [71]:

test_a * test_a  # Matrix내 element들 간 같은 위치에 있는 값들끼리 연산

Out[71]:

array([[ 1.,  4.,  9.],
       [16., 25., 36.]])

Element-wise operations¶

• Array간 shape이 같을 때 일어나는 연산

In [72]:

matrix_a = np.arange(1, 13).reshape(3, 4)
matrix_a * matrix_a

Out[72]:

array([[  1,   4,   9,  16],
       [ 25,  36,  49,  64],
       [ 81, 100, 121, 144]])

Dot product¶

In [73]:

test_a = np.arange(1, 7).reshape(2, 3)
test_b = np.arange(7, 13).reshape(3, 2)

In [74]:

test_a.dot(test_b)

Out[74]:

array([[ 58,  64],
       [139, 154]])

• https://www.mathsisfun.com/algebra/matrix-multiplying.html

transpose¶

• transpose 또는 T attribute사용

In [75]:

test_a = np.arange(1, 7).reshape(2, 3)
test_a

Out[75]:

array([[1, 2, 3],
       [4, 5, 6]])

In [76]:

test_a.transpose()

Out[76]:

array([[1, 4],
       [2, 5],
       [3, 6]])

In [77]:

test_a.T

Out[77]:

array([[1, 4],
       [2, 5],
       [3, 6]])

broadcasting¶

• Shape이 다른 배열 간 연산을 지원하는 기능

In [78]:

test_matrix = np.array([[1, 2, 3], [4, 5, 6]], float)
scalar = 3

In [79]:

test_matrix + scalar  # Matrix - Scalar 덧셈

Out[79]:

array([[4., 5., 6.],
       [7., 8., 9.]])

In [80]:

test_matrix - scalar  # Matrix - Scalar 뺄셈

Out[80]:

array([[-2., -1.,  0.],
       [ 1.,  2.,  3.]])

In [81]:

test_matrix * 5  # Matrix - Scalar 곱셈

Out[81]:

array([[ 5., 10., 15.],
       [20., 25., 30.]])

Scalar-vector 외에도 vecto - matrix 간의 연산도 지원

In [82]:

test_matrix = np.arange(1, 13).reshape(4, 3)
test_vector = np.arange(10, 40, 10)
test_matrix,test_vector

Out[82]:

(array([[ 1,  2,  3],
        [ 4,  5,  6],
        [ 7,  8,  9],
        [10, 11, 12]]),
 array([10, 20, 30]))

In [83]:

test_matrix + test_vector

Out[83]:

array([[11, 22, 33],
       [14, 25, 36],
       [17, 28, 39],
       [20, 31, 42]])