[Numpy] Operation, Dot product, Broadcasting

In [2]:

import numpy as np

Operation

In [4]:

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

In [6]:

test_a + test_a #matrix + matrix

Out[6]:

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

In [8]:

test_a - test_a #matrix - matrix

Out[8]:

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

In [10]:

test_a * test_a #element 곱 연산

Out[10]:

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

In [13]:

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

Out[13]:

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

---

Dot product

In [15]:

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

 

In [17]:

test_a.dot(test_b)

Out[17]:

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

 

In [19]:

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

Out[19]:

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

 

In [21]:

test_a.transpose() #전치행렬

Out[21]:

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

 

In [23]:

test_a.T

Out[23]:

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

 

In [25]:

test_a.T.dot(test_a)

Out[25]:

array([[17, 22, 27],
       [22, 29, 36],
       [27, 36, 45]])

---

Broadingcasting

broadingcasting은 간단히 말해서 분배법칙이 된다는 말이다.

In [27]:

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

In [29]:

test_matrix + scalar #matrix + Scalar

Out[29]:

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

In [31]:

test_matrix - scalar #matrix - Scalar

Out[31]:

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

In [33]:

test_matrix * 5 #matrix * Scalar

Out[33]:

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

In [35]:

test_matrix / 5 #matrix / Scalar

Out[35]:

array([[0.2, 0.4, 0.6],
       [0.8, 1. , 1.2]])

In [37]:

test_matrix // 0.2 #matrix // Scalar

Out[37]:

array([[ 4.,  9., 14.],
       [19., 24., 29.]])

In [39]:

test_matrix ** 2 #matrix ** Scalar

Out[39]:

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

 

다음과 같은 경우에는 각 행별로 test_vector가 더해지는 것이다.

In [43]:

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

Out[43]:

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

---

Performance

%timeit을 사용하여 속도가 얼마나 나오는지 확인할 수 있다.

In [48]:

def scalar_vector_product(scalar, vector):
    result = []
    for value in vector:
        result.append(scalar * value)
    return result

iternation_max = 10000000

vector = list(range(iternation_max))
scalar = 2

%timeit scalar_vector_product(scalar, vector) #for loop을 이용한 성능

 

1.39 s ± 17.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [50]:

%timeit [scalar * value for value in range(iternation_max)] # list comprehention을 이용한 성능

 

1.15 s ± 25.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [51]:

%timeit np.arange(iternation_max) * scalar #numpy를 이용한 성능

 

36.1 ms ± 2.19 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

 

위와 같은 결과를 통해서 numpy를 사용한 속도가 빠르다는 것을 확인할 수 있다. 하지만 concatenate와 같이 matrix끼리 결합을 할때에는 메모리를 할당해야하기때문에 numpy보다는 List를 사용하는 것이 빠르다고 한다.