불굴의관돌로그

시계열 예측(Time-Series Forecasting)이란?

시계열(Time-Series) 데이터란 시간의 흐름에 따라 순차적으로(sequentially) 기록된 데이터를 가리킨다. 

관측된 시계열 데이터를 분석하여 미래를 예측하는 문제가 바로 시계열 예측 문제이다.

시계열 예측 문제는 흔하게 접하는 문제로써 주로 경제 지표를 예측하거나, 어떤 상품의 수요를 예측하는 문제에 이르기까지 다양한 어플리케이션을 가지고 있다.

특히, 예측된 결과를 바탕으로 여러 정책이나 비즈니스 전략을 결정하는 과정에 활용되기에, 실제 비즈니스 영역에서는 시계열 예측 문제가 매우 중요하게 여겨지고 있다. 

일례로 McKinsey Global Institute의 연구에 따르면, 시계열 데이터가 텍스트나 이미지 데이터 보다 더 큰 잠재적 가치를 가지고 있다고 보고있다.

시계열 예측 문제의 주요 챌린지

무엇보다 시계열 문제가 4가지 어려운 점이 있다.

1.예측값은 완벽할 수 없으며, 항상 변동의 가능성을 내포.

따라서 시계열 예측에 있어 불확실성(uncertainty)이 고려되어야 한다. 다시 말해 예측값에 대해 적합한 확률 분포 모델(probability distribution)이 고려되어야 한다. 단순히 어떤 에측 값을 제공한다기 보다는 그 예측값의 불확실성(또는 신뢰도)에 대해 정량적인 평가가 함께 고려되어야 예측 모델로써 더욱 가치가 있다.

2. 시계열 데이터에 숨겨진 여려 형태의 패턴을 찾아 학습하는 문제.

보통 trend,seasonality,cycle 등의 유형으로 패턴을 구분하곤 한다. 대게 시계열 데이터에는 이러한 패턴이 복잡하게 섞여있고 데이터의 길이가 불충분 하거나, 노이즈, 아웃라이어 데이터로 인해 손쉽게 패턴을 구분해 내어 찾기가 어렵다.

3. 다변량 시계열 데이터(multiple time-series)를 다뤄야 하는 경우가 많아지고 있다.

과거에는 주로 다변량의 시계열 데이터(unvariate time-series)의 분석과 예측 문제가 주로 다뤄졌지만 근래에는 다변량 시계열 데이터를 다뤄야 하는 경우가 많아지고 있다. 

순차적으로 관찰된 수많은 변수들에 대해, 이 변수들간의 상관 관계를 학습할 수 있어야 한다. 가령, 어떤 상품의 수요가 다른 상품들의 수요 변화에 영향을 받거나, 어떤 지역의 택시 수요가 다른 지역의 택시 수요와 일정한 시간 차이를 두고 상관 관계를 보일 수 있다. 이 변수가 적게는 수백에서 많게는 수백만에 이를 수 있으므로, 이를 효율적으로 처리하고 학습할 수 있는 알고리즘이 매우 중요해 지고 있다.

4. 시계열 데이터에는 노이즈 데이터 또는 관찰되지 못한 기간이 종종 존재한다.

이는 측정하고 데이터를 기록하는 과정에서의 오류나 예측치 못한 상황으로 인해 발생할 수 있다. 예를 들어 상품의 품절로 인하여 장기간 판매량이 없는 경우, 해당 상품에 대한 실제 수요를 판매량으로 유추할 수 없는 경우이다. 

시계열 예측 문제에 있어서는 이에 대한 적절한 전처리 과정이 매우 중요하다.

시계열 예측 모델의 평가

일반적으로 supervised machine learning 모델은 데이터 셋을 학습 데이터와 테스트 데이터로 랜덤하게 나누어 평가를 한다. 하지만 시계열 예측 문제는 평가와 학습 대상의 데이터를 특정 시간 기준으로 엄밀하게 분리시켜, data leak이 없이 평가가 이루어져야 한다. 

가령 시계열 데이터의 중간 구간을 잘라내 테스트용으로, 그 이전과 이후를 학습용으로 사용하면 정확한 평가가 이루어질 수 없다. 학습 데이터는 반드시 테스트 데이터 보다 이전에 관찰된 것이어야 한다.

모델링 과정에서는 최적의 성능을 가지되, robust한 모델을 찾기 위해 cross-validation을 통해 성능을 평가한다. 제한된 데이터 셋으로부터 여러 쌍의 학습 및 테스트 데이터를 샘플링해서 모델의 성능이 기대치에 부합하며, 안정적인지를 확인하게 된다. 시계열 예측 모델에서는 앞서 언급한 chronological testing 기준을 지키며, cross-validation을 할 수 있는 방법으로 크게 두가지가 고려된다. 

1. Sliding window

슬라이딩 윈도우(Sliding Window) 알고리즘은 배열이나 리스트의 요소의 일정 범위의 값을 비교할 때 사용하면 유용한 알고리즘이다. 

예를 들어 정수로 이루어진 배열 [2,4,7,10,8,4,5,6,7,1] 에서 길이가 3인 서브배열의 합계가 가장 큰 서브배열은 무엇일까? 

특정 길이의 하위 배열의 최대 합계값을 구하는 단순한 방식을 먼저 살펴보자. 

단순하게 for 문으로 모든 배열 요소를 특정 길이만큼 순회하며 합계를 구해서 최대 값을 구하는 단순하고 비효율적인 방법이다.

import sys

def max_sub_array(arr, k):
    maxsum = -sys.maxsize - 1
    arraysize = len(arr)

    for i in range(arraysize - k + 1):
        current_sum = 0
        for j in range(i, i + k):
            current_sum += arr[j]

        maxsum = max(maxsum, current_sum)

    return maxsum

if __name__ == '__main__':
    print(max_sub_array([2, 4, 7, 10, 8, 4, 5, 6, 7, 1], 3))
    
25 (7 + 10 + 8)

설명이 크게 필요 없는 단순한 코드이다. 

물론 위와 같이 작성해도 데이터가 방대하지 않다면 큰 차이는 없을 것이다. 

그렇다면 좀 더 효율적인 코드를 작성할 방법을 찾아보자.

우선 기존 단순한 방식에서 서브 배열의 요소를 순회하다 보면 중복되는 요소들이 존재한다.

위 이미지 처럼 범위가 5인 서브배열을 탐색하는 경우 0~4 범위의 서브배열과 1~5 범위의 서브배열은 공통적으로 1~4 범위가 중복된다. 

중복되는 요소(공통 요소)들을 재상용하는 방법이 슬라이딩 윈도우 알고리즘의 핵심이다.

def max_sub_array(arr, k):
    window_sum = 0
    max_sum = 0
    window_start = 0

    for window_end in range(len(arr)):
        window_sum += arr[window_end]  # 슬라이딩 인덱스 범위 요소 합산
        
        # 슬라이딩 윈도우의 범위가 k 보다 커진 경우
        if window_end >= (k - 1):
            max_sum = max(max_sum, window_sum)
            window_sum -= arr[window_start]  # 슬라이드 윈도우 범위를 벗어난 요소를 합계에서 제거
            window_start += 1  # 슬라이드 윈도우 시작 인덱스 증가

    return max_sum


if __name__ == '__main__':
    print(max_sub_array([2, 4, 7, 10, 8, 4], 3))

25 (7 + 10 + 8)

이해를 쉽게 하기 위해 기존 배열보다 길이가 짧은 배열로 변경했다. 각 루프마다 다음과 같은 식으로 진행된다.

우선 슬라이딩 윈도우를 관리하기 위한 변수들로 window_start, window_end, window_sum 등을 사용한다.

-window_start: 슬라이딩 윈도우 시작 인덱스

-window_end: 슬라이딩 윈도우 끝 인덱스

-window_sum: 슬라이딩 윈도우 합계

슬라이딩 윈도우는 하위 윈도우의 범위 k 와 동일하게 유지하며 범위 내의 요소는 모두 합산하고 범위 밖으로 벗어난 요소들은 빼준다. 다만 슬라이딩 윈도우의 범위가 k 보다 커질때까지 (window_end>=k-1)는 요소들을 합산하기만 하고 이후부터는 범위 밖의 요소들을 차감시켜준다.

이렇게 하면 기존처럼 매번 서브배열의 합계를 구할 필요 없이 모든 요소를 1번만 순회하면서 최대값을 구하게 되므로 빠르고 효율적으로 처리된다.

위 sliding window 알고리즘을 통해 고정된 사이즈 2개의 window를 움직여가며 학습,테스트 데이터를 추출하여 cross-validation을 하는 방법이다. 

2. Expanding window

위 sliding window를 이해하였다면 이는 간단하게 이해할 수 있다. 데이터 길이가 충분치 않을때 데이터를 확장해 가며 학습,테스트 데이터를 추출하는 알고리즘이다.

시계열 예측 모델의 평가는 문제에 따라 다양한 지표가 활용될 수 있다. Root Mean Squared Error(RMSE) 또는 Mean Absolute Percentage Error(MAPE)가 많이 사용되는 지표이다. 일반적으로 baseline 예측 모델(e.g.최근 평균값으로 예측)과의 비교가 매우 유용하다. 머신러닝을 도입하기 이전의 다소 단순한 방식과의 비교를 통해 개발된 예측 모델의 도입 효과를 가늠해 보곤한다. 예측 모델의 평가는 특정 성능 지표 뿐만 아니라 residual error의 분포, 시간축에 따른 Error의 propagation 패턴을 분석하여 모델의 bias가 있는지 혹은 overfitting 여부 등에 대한 검토가 반드시 필요하다.

주요한 시계열 패턴

전통적으로 시계열 데이터를 분석할 때 보통 trend, seasonality,cycles 그리고 random noise의 패턴으로 분류하여 분석한다.

Trend 는 전체적으로 긴구간에 걸쳐 일정하게 증가 또는 감소하는 패턴을 가리킨다.

Seasonal component는 규칙적인 주기에 따라 반복되는 패턴을 나타내며, 주기가 규칙적이지 않지만 wave형태로 반복되는 패턴을 cyclical component로 분류하여 분석한다.

Trend,seasonality,cycles를 제외한 그외 불규칙한 fluctuation은 random component로 분류한다.

일반적을 전통적인 시계열 분석 모델에서는 이 4가지 유형이 패턴이 linear한 조합으로 이루어진 모델(additive model)을 가정한다. 간혹 seasonal 또는 cyclic 패턴의 변동폭이 시계열 값의 크기에 따라서 함께 변하는 경우 multiplicative model을 가정하기도 한다. 분석 모델 안에서 패턴이 어떻게 구성되느냐에 따라 , 개별 component에 대한 수학적 모델 또한 매우 다양하다. 주어진 시계열 데이터에 맞는 모델을 찾아가는 과정이 예측 모델을 만들어 가는 과정이라고 볼 수 있다.

대표적인 전통 시계열 예측 모델: ARIMA

전통적으로 시계열 데이터에서 패턴을 추출하고 그 패턴을 이용하여 미래를 예측하는 모델로 Autoregressive integrated moving average(ARIMA)가 있다. 

ARIMA모델은 크게 세가지 component로 조합되어 만들어진다. 먼저 Autoregressive는 예측 시점(t-0)이 과거 p 개의 데이터 포인트(t-1,t-2,...,t-p)와 연관이 있다는 의미이다. 일련의 과거 관측값을 이용하여 미래의 값을 예측하는 regression 모델인 것이다. 

Moving average는 과거의 예측 에러를 예측 대상과 연관 시키는 component이다. 가령 autoregressive 모델로 미래를 예측함에 있어, 과거의 에러들을 고려하여 그 예측값을 보정하는 역할을 한다고 볼 수 있다. 마지막으로 integrated의 의미는 non-stationary time-series의 데이터를 differencing을 통해 시간에 따라 데이터의 통계적 특성(e.g. mean, std)이 변하지 않는 stationary time-series 데이터로 변환하는 모델을 의미한다. 적합한 ARIMA 예측 모델을 만들기 위해서는 differencing order을 조절하여 데이터로부터 non-stationary를 반드시 제거해야 한다.

ARIMA 모델은 추가적인 component를 고려함으로써 다양한 형태로 변형, 발전될 수 있다. 예를 들어 추가적인 seasonal component를 고려하는 SARIMA가 있으며, univariate time-series가 아닌 추가적인 covariates를 함께 고려하여 예측할 수 있는 ARIMAX 모델이 존재한다. 물론 이 두가지를 모두 혼합한 SARIMAX모델도 사용되곤 한다.

Numpy에서는 배열에 적용되는 다양한 함수가 있다. 

다만,

단일 배열과 다중 배열에 사용되는 함수가 각각 다르므로 따로 정리해보자.

단일 배열에 적용되는 함수

우선 이차원 배열을 생성하자.

single_arr=np.random.randn(11,4)
single_arr

array([[-0.85420188,  0.42498577, -1.21781935, -2.469909  ],
       [-0.95437149,  0.84229281, -0.58423631,  0.16811405],
       [ 0.41291648, -0.60213293,  0.44054662,  0.00754592],
       [-0.49192662, -1.22210946,  1.82552474,  1.00134016],
       [-1.06566936,  0.74219896, -0.47628828, -0.5175951 ],
       [-0.0755429 ,  0.79078645,  0.95086558, -1.86214404],
       [ 1.50346299, -0.52695526, -0.28902625, -0.82038604],
       [ 0.81427752, -0.74730953,  0.64814457, -0.94949558],
       [ 0.70329552,  0.37535518, -0.43012094,  1.0470845 ],
       [-0.2881095 , -0.98918133, -1.76115028,  1.28901781],
       [ 1.37016394,  0.88699756,  0.43978861,  0.65941833]])

np.abs()

각 성분(요소)마다 절댓값 처리

np.abs(single_arr)

array([[0.85420188, 0.42498577, 1.21781935, 2.469909  ],
       [0.95437149, 0.84229281, 0.58423631, 0.16811405],
       [0.41291648, 0.60213293, 0.44054662, 0.00754592],
       [0.49192662, 1.22210946, 1.82552474, 1.00134016],
       [1.06566936, 0.74219896, 0.47628828, 0.5175951 ],
       [0.0755429 , 0.79078645, 0.95086558, 1.86214404],
       [1.50346299, 0.52695526, 0.28902625, 0.82038604],
       [0.81427752, 0.74730953, 0.64814457, 0.94949558],
       [0.70329552, 0.37535518, 0.43012094, 1.0470845 ],
       [0.2881095 , 0.98918133, 1.76115028, 1.28901781],
       [1.37016394, 0.88699756, 0.43978861, 0.65941833]])

np.sqrt()

제곱근 처리

np.sqrt(single_arr)

array([[       nan, 0.65190932,        nan,        nan],
       [       nan, 0.91776512,        nan, 0.41001713],
       [0.64258577,        nan, 0.66373686, 0.08686725],
       [       nan,        nan, 1.35111981, 1.00066986],
       [       nan, 0.8615097 ,        nan,        nan],
       [       nan, 0.88926174, 0.97512337,        nan],
       [1.22615782,        nan,        nan,        nan],
       [0.90237327,        nan, 0.80507426,        nan],
       [0.83862717, 0.61266237,        nan, 1.02327147],
       [       nan,        nan,        nan, 1.1353492 ],
       [1.17054002, 0.94180548, 0.66316559, 0.81204577]])

np.square()

제곱 처리

np.square(single_arr)

array([[7.29660856e-01, 1.80612901e-01, 1.48308397e+00, 6.10045049e+00],
       [9.10824947e-01, 7.09457185e-01, 3.41332063e-01, 2.82623330e-02],
       [1.70500017e-01, 3.62564070e-01, 1.94081323e-01, 5.69408884e-05],
       [2.41991798e-01, 1.49355153e+00, 3.33254059e+00, 1.00268211e+00],
       [1.13565117e+00, 5.50859302e-01, 2.26850526e-01, 2.67904688e-01],
       [5.70672981e-03, 6.25343204e-01, 9.04145352e-01, 3.46758044e+00],
       [2.26040097e+00, 2.77681849e-01, 8.35361732e-02, 6.73033254e-01],
       [6.63047882e-01, 5.58471536e-01, 4.20091384e-01, 9.01541857e-01],
       [4.94624593e-01, 1.40891513e-01, 1.85004022e-01, 1.09638595e+00],
       [8.30070859e-02, 9.78479713e-01, 3.10165031e+00, 1.66156692e+00],
       [1.87734923e+00, 7.86764671e-01, 1.93414018e-01, 4.34832532e-01]])

np.exp()

각 성분을 exponential의 지수로 삼은 값 계산한다.

np.exp(single_arr)

array([[0.42562275, 1.52956865, 0.29587466, 0.08459256],
       [0.38505408, 2.32168407, 0.55753148, 1.18307153],
       [1.5112188 , 0.5476423 , 1.55355619, 1.00757446],
       [0.61144723, 0.29460805, 6.20605075, 2.7219272 ],
       [0.34449719, 2.10054947, 0.62108441, 0.59595203],
       [0.92723995, 2.20512996, 2.58794877, 0.15533922],
       [4.49723603, 0.59039985, 0.74899254, 0.44026166],
       [2.25754406, 0.47363915, 1.91198997, 0.38693615],
       [2.02040002, 1.45550829, 0.65043043, 2.84933177],
       [0.7496795 , 0.37188101, 0.17184708, 3.62922023],
       [3.93599591, 2.42782929, 1.55237902, 1.93366725]])

np.log(), np.log10(), np.log2()

각 성분을 밑을 지정해 로그처리한다.

단, 밑이 자연로그, 상용로그, 2 만 가능하다.

np.log(single_arr)

array([[            nan, -8.55699603e-01,             nan,
                    nan],
       [            nan, -1.71627565e-01,             nan,
        -1.78311268e+00],
       [-8.84509941e-01,             nan, -8.19739009e-01,
        -4.88674844e+00],
       [            nan,             nan,  6.01867476e-01,
         1.33926199e-03],
       [            nan, -2.98137927e-01,             nan,
                    nan],
       [            nan, -2.34727327e-01, -5.03825721e-02,
                    nan],
       [ 4.07771109e-01,             nan,             nan,
                    nan],
       [-2.05454035e-01,             nan, -4.33641505e-01,
                    nan],
       [-3.51978101e-01, -9.79882548e-01,             nan,
         4.60096339e-02],
       [            nan,             nan,             nan,
         2.53880542e-01],
       [ 3.14930398e-01, -1.19913048e-01, -8.21461109e-01,
        -4.16397153e-01]])

np.log10(single_arr)

array([[            nan, -3.71625616e-01,             nan,
                    nan],
       [            nan, -7.45369044e-02,             nan,
        -7.74395996e-01],
       [-3.84137787e-01,             nan, -3.56008128e-01,
        -2.12228788e+00],
       [            nan,             nan,  2.61387724e-01,
         5.81634093e-04],
       [            nan, -1.29479656e-01,             nan,
                    nan],
       [            nan, -1.01940783e-01, -2.18808730e-02,
                    nan],
       [ 1.77092743e-01,             nan,             nan,
                    nan],
       [-8.92275539e-02,             nan, -1.88328113e-01,
                    nan],
       [-1.52862147e-01, -4.25557584e-01,             nan,
         1.99817301e-02],
       [            nan,             nan,             nan,
         1.10258919e-01],
       [ 1.36772534e-01, -5.20775749e-02, -3.56756027e-01,
        -1.80838986e-01]])

np.log2(single_arr)

array([[            nan, -1.23451357e+00,             nan,
                    nan],
       [            nan, -2.47606237e-01,             nan,
        -2.57248781e+00],
       [-1.27607811e+00,             nan, -1.18263340e+00,
        -7.05008774e+00],
       [            nan,             nan,  8.68311223e-01,
         1.93214663e-03],
       [            nan, -4.30122108e-01,             nan,
                    nan],
       [            nan, -3.38639951e-01, -7.26866869e-02,
                    nan],
       [ 5.88289357e-01,             nan,             nan,
                    nan],
       [-2.96407518e-01,             nan, -6.25612449e-01,
                    nan],
       [-5.07797062e-01, -1.41367169e+00,             nan,
         6.63778706e-02],
       [            nan,             nan,             nan,
         3.66272199e-01],
       [ 4.54348523e-01, -1.72997959e-01, -1.18511787e+00,
        -6.00734107e-01]])

np.sign()

각 성분(요소)의 부호 계산한다.

양수인 경우 1, 음수인 경우, -1, 0인 경우 0을 반환한다.

np.sign(single_arr)

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.,  1., -1.],
       [ 1.,  1., -1.,  1.],
       [-1., -1., -1.,  1.],
       [ 1.,  1.,  1.,  1.]])

np.ceil()

각 성분의 소수 첫 번째 자리에서 반올림 값 계산한다.

np.ceil(single_arr)

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

np.floor()

각 성분의 소수 첫 번째 자리에서 반내림한 값 계산한다.

np.floor(single_arr)

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

np.isnan()

각 성분이 결측치(NaN)인 경우 True, 아닌 경우 False를 반환한다.

np.isnan(np.log(single_arr))

array([[ True, False,  True,  True],
       [ True, False,  True, False],
       [False,  True, False, False],
       [ True,  True, False, False],
       [ True, False,  True,  True],
       [ True, False, False,  True],
       [False,  True,  True,  True],
       [False,  True, False,  True],
       [False, False,  True, False],
       [ True,  True,  True, False],
       [False, False, False, False]])

np.isinf()

각 성분이 무한대인 경우 True를, 아닌 경우 False를 반환한다.

np.isinf(np.square(single_arr))

array([[False, False, False, False],
       [False, False, False, False],
       [False, False, False, False],
       [False, False, False, False],
       [False, False, False, False],
       [False, False, False, False],
       [False, False, False, False],
       [False, False, False, False],
       [False, False, False, False],
       [False, False, False, False],
       [False, False, False, False]])

np.cos(),np.tan(),np.sin()

각 성분에 대해 삼각함수 값을 계산해준다. 

cos, cosh, sin, sinh, tan, tanh

np.sin(single_arr)

array([[-0.75404694,  0.41230781, -0.93834775, -0.62230479],
       [-0.81595055,  0.74617153, -0.55156252,  0.16732328],
       [ 0.40128239, -0.56640157,  0.42643396,  0.00754585],
       [-0.47232493, -0.93982217,  0.96773177,  0.84219432],
       [-0.87511304,  0.67591015, -0.45848373, -0.49479168],
       [-0.07547107,  0.71090659,  0.81391869, -0.95785762],
       [ 0.99773397, -0.50290398, -0.285019  , -0.73140914],
       [ 0.72722988, -0.67966771,  0.60370829, -0.81312199],
       [ 0.64673474,  0.36660301, -0.41698073,  0.86596887],
       [-0.28414016, -0.83557651, -0.98193733,  0.96056242],
       [ 0.97994075,  0.77517848,  0.4257482 ,  0.61265723]])

np.cos(single_arr)

array([[ 0.65682054,  0.9110446 ,  0.34569277, -0.78277503],
       [ 0.5781217 ,  0.66575374,  0.83413355,  0.98590208],
       [ 0.91595439,  0.82412939,  0.9045187 ,  0.99997153],
       [ 0.88142451,  0.34166399, -0.2519826 ,  0.53917412],
       [ 0.48391856,  0.73698404,  0.8887028 ,  0.86901162],
       [ 0.99714799,  0.70328644,  0.5809788 , -0.28724341],
       [ 0.06728247,  0.86434228,  0.95852187,  0.68193891],
       [ 0.68639398,  0.73352015,  0.79720531,  0.58209332],
       [ 0.762715  ,  0.93037747,  0.90891533,  0.5000979 ],
       [ 0.95878275,  0.5493741 , -0.18920647,  0.27806446],
       [ 0.19928907,  0.6317423 ,  0.90484168,  0.79034873]])

np.tan(single_arr)

array([[-1.14802582e+00,  4.52566003e-01, -2.71439794e+00,
         7.94998259e-01],
       [-1.41138197e+00,  1.12079209e+00, -6.61240061e-01,
         1.69715924e-01],
       [ 4.38103027e-01, -6.87272628e-01,  4.71448467e-01,
         7.54606189e-03],
       [-5.35865442e-01, -2.75072059e+00, -3.84047063e+00,
         1.56200807e+00],
       [-1.80838908e+00,  9.17129963e-01, -5.15902193e-01,
        -5.69372924e-01],
       [-7.56869302e-02,  1.01083505e+00,  1.40094389e+00,
         3.33465487e+00],
       [ 1.48290337e+01, -5.81834292e-01, -2.97352632e-01,
        -1.07254350e+00],
       [ 1.05949339e+00, -9.26583562e-01,  7.57280817e-01,
        -1.39689284e+00],
       [ 8.47937613e-01,  3.94036848e-01, -4.58767408e-01,
         1.73159868e+00],
       [-2.96355099e-01, -1.52096086e+00,  5.18976617e+00,
         3.45445948e+00],
       [ 4.91718257e+00,  1.22704856e+00,  4.70522307e-01,
         7.75173299e-01]])

두 개의 배열에 적용되는 함수

우선 두개의 배열을 생성하자.

single_arr

array([[-0.85420188,  0.42498577, -1.21781935, -2.469909  ],
       [-0.95437149,  0.84229281, -0.58423631,  0.16811405],
       [ 0.41291648, -0.60213293,  0.44054662,  0.00754592],
       [-0.49192662, -1.22210946,  1.82552474,  1.00134016],
       [-1.06566936,  0.74219896, -0.47628828, -0.5175951 ],
       [-0.0755429 ,  0.79078645,  0.95086558, -1.86214404],
       [ 1.50346299, -0.52695526, -0.28902625, -0.82038604],
       [ 0.81427752, -0.74730953,  0.64814457, -0.94949558],
       [ 0.70329552,  0.37535518, -0.43012094,  1.0470845 ],
       [-0.2881095 , -0.98918133, -1.76115028,  1.28901781],
       [ 1.37016394,  0.88699756,  0.43978861,  0.65941833]])
       
double_arr=np.random.rand(11,4)
double_arr

array([[0.48705458, 0.9637593 , 0.6738098 , 0.6541084 ],
       [0.61583841, 0.39743118, 0.55485998, 0.93706706],
       [0.0448264 , 0.88860695, 0.38479569, 0.45587065],
       [0.65356226, 0.73741626, 0.28991024, 0.59693486],
       [0.81154215, 0.91903639, 0.98248847, 0.08662736],
       [0.53407128, 0.55608402, 0.71851739, 0.29082239],
       [0.35009501, 0.99887153, 0.4568631 , 0.95589646],
       [0.30591951, 0.3999088 , 0.61395523, 0.38426602],
       [0.20310461, 0.53358661, 0.81670187, 0.7676948 ],
       [0.07961264, 0.57528379, 0.92982623, 0.99493861],
       [0.6184389 , 0.14453175, 0.68750759, 0.66940273]])

np.add(),np.substract(),np.multiply(),np.divide()

위 함수들은 동일한 shape일때 사칙연산을 해주는 함수들이다.

간단하게 multiply만 예로하고 넘어가겠다.

np.multiply(single_arr,double_arr)

array([[-0.41604294,  0.40958398, -0.82057861, -1.61558823],
       [-0.58773863,  0.33475342, -0.32416935,  0.15753414],
       [ 0.01850956, -0.53505951,  0.16952044,  0.00343996],
       [-0.32150467, -0.90120339,  0.52923832,  0.59773485],
       [-0.8648356 ,  0.68210786, -0.46794774, -0.0448379 ],
       [-0.04034529,  0.43974371,  0.68321346, -0.54155318],
       [ 0.52635489, -0.52636061, -0.13204543, -0.78420411],
       [ 0.24910338, -0.29885566,  0.39793175, -0.36485889],
       [ 0.14284257,  0.2002845 , -0.35128057,  0.80384132],
       [-0.02293716, -0.56905999, -1.63756373,  1.28249359],
       [ 0.84736269,  0.12819931,  0.30235801,  0.44141643]])

np.maximum(),np.minimum()

각 shape의 성분끼리 최대 최소값을 비교하여 하나의 배열로 만들어준다.

np.maximum(single_arr,double_arr)

array([[0.48705458, 0.9637593 , 0.6738098 , 0.6541084 ],
       [0.61583841, 0.84229281, 0.55485998, 0.93706706],
       [0.41291648, 0.88860695, 0.44054662, 0.45587065],
       [0.65356226, 0.73741626, 1.82552474, 1.00134016],
       [0.81154215, 0.91903639, 0.98248847, 0.08662736],
       [0.53407128, 0.79078645, 0.95086558, 0.29082239],
       [1.50346299, 0.99887153, 0.4568631 , 0.95589646],
       [0.81427752, 0.3999088 , 0.64814457, 0.38426602],
       [0.70329552, 0.53358661, 0.81670187, 1.0470845 ],
       [0.07961264, 0.57528379, 0.92982623, 1.28901781],
       [1.37016394, 0.88699756, 0.68750759, 0.66940273]])

Statistic Function

통계 함수를 통해 array의 합이나 평균등을 구할 때, axis라는 인자에 대한 값을 지정해주어 열 또는 행의 합 또는 평균등을 구할 수 있다.

single_arr

array([[-0.85420188,  0.42498577, -1.21781935, -2.469909  ],
       [-0.95437149,  0.84229281, -0.58423631,  0.16811405],
       [ 0.41291648, -0.60213293,  0.44054662,  0.00754592],
       [-0.49192662, -1.22210946,  1.82552474,  1.00134016],
       [-1.06566936,  0.74219896, -0.47628828, -0.5175951 ],
       [-0.0755429 ,  0.79078645,  0.95086558, -1.86214404],
       [ 1.50346299, -0.52695526, -0.28902625, -0.82038604],
       [ 0.81427752, -0.74730953,  0.64814457, -0.94949558],
       [ 0.70329552,  0.37535518, -0.43012094,  1.0470845 ],
       [-0.2881095 , -0.98918133, -1.76115028,  1.28901781],
       [ 1.37016394,  0.88699756,  0.43978861,  0.65941833]])

np.sum()

전체 성분의 합을 계산해준다.

np.sum(single_arr)

-1.8515573809143309

axis=0 : 행별 전체 합을 계산해준다.

np.sum(single_arr,axis=0)

array([ 1.0742947 , -0.02507179, -0.45377129, -2.447009  ])

aixs=1 : 열별 전체 합을 계산해준다.

np.sum(single_arr,axis=1)

array([-4.11694447, -0.52820094,  0.25887608,  1.11282882, -1.31735377,
       -0.19603492, -0.13290456, -0.23438302,  1.69561427, -1.74942331,
        3.35636844])

np.mean()

평균을 계산해준다.

np.mean(single_arr,axis=0)

array([ 0.09766315, -0.00227925, -0.04125194, -0.22245536])

np.std(),np.var(),np.min(),np.max()

표준편차,분산,최대 최소를 구해준다.

np.std(single_arr)

0.9683579692373014

np.min(single_arr,axis=1)

array([-2.469909  , -0.95437149, -0.60213293, -1.22210946, -1.06566936,
       -1.86214404, -0.82038604, -0.94949558, -0.43012094, -1.76115028,
        0.43978861])

np.argmin(),np.agrmax()

전체 성분의 최소값, 최대값이 위치한 인덱스를 반환.

np.argmin(single_arr)

3

np.argmax(single_arr,axis=1)

array([1, 1, 2, 2, 1, 2, 0, 0, 3, 3, 0], dtype=int64)

np.cumsum(), np.cumprod()

처음 성분부터 각 성분까지의 누적합 또는 누적곱을 계산해준다.

np.cumsum(single_arr)

array([-0.85420188, -0.42921612, -1.64703547, -4.11694447, -5.07131596,
       -4.22902315, -4.81325946, -4.64514541, -4.23222893, -4.83436187,
       -4.39381525, -4.38626933, -4.87819595, -6.10030541, -4.27478067,
       -3.27344051, -4.33910986, -3.5969109 , -4.07319918, -4.59079428,
       -4.66633718, -3.87555073, -2.92468515, -4.78682919, -3.2833662 ,
       -3.81032147, -4.09934772, -4.91973375, -4.10545623, -4.85276576,
       -4.20462119, -5.15411677, -4.45082125, -4.07546607, -4.50558701,
       -3.45850251, -3.74661201, -4.73579335, -6.49694363, -5.20792582,
       -3.83776188, -2.95076432, -2.51097571, -1.85155738])

np.cumprod(single_arr)

array([-8.54201882e-01, -3.63023641e-01,  4.42097215e-01, -1.09193989e+00,
        1.04211631e+00,  8.77767075e-01, -5.12823395e-01, -8.62128166e-02,
       -3.55986925e-02,  2.14351452e-02,  9.44318071e-03,  7.12574735e-05,
       -3.50534480e-05,  4.28391504e-05,  7.82039290e-05,  7.83087347e-05,
       -8.34512188e-05, -6.19374081e-05,  2.95000616e-05, -1.52690873e-05,
        1.15347114e-06,  9.12149347e-07,  8.67331419e-07, -1.61509603e-06,
       -2.42823712e-06,  1.27957233e-06, -3.69829992e-07,  3.03403362e-07,
        2.47054538e-07, -1.84626211e-07, -1.19664476e-07,  1.13620891e-07,
        7.99090642e-08,  2.99942814e-08, -1.29011685e-08, -1.35086135e-08,
        3.89195992e-09, -3.84985411e-09,  6.78017165e-09,  8.73976203e-09,
        1.19749068e-08,  1.06217131e-08,  4.67130840e-09,  3.08034638e-09])

np.sort()

전체 성분에 대해서 정렬해준다.

오름차순

np.sort(single_arr)

array([[-2.469909  , -1.21781935, -0.85420188,  0.42498577],
       [-0.95437149, -0.58423631,  0.16811405,  0.84229281],
       [-0.60213293,  0.00754592,  0.41291648,  0.44054662],
       [-1.22210946, -0.49192662,  1.00134016,  1.82552474],
       [-1.06566936, -0.5175951 , -0.47628828,  0.74219896],
       [-1.86214404, -0.0755429 ,  0.79078645,  0.95086558],
       [-0.82038604, -0.52695526, -0.28902625,  1.50346299],
       [-0.94949558, -0.74730953,  0.64814457,  0.81427752],
       [-0.43012094,  0.37535518,  0.70329552,  1.0470845 ],
       [-1.76115028, -0.98918133, -0.2881095 ,  1.28901781],
       [ 0.43978861,  0.65941833,  0.88699756,  1.37016394]])

내림차순

np.sort(single_arr)[::-1]

array([[ 0.43978861,  0.65941833,  0.88699756,  1.37016394],
       [-1.76115028, -0.98918133, -0.2881095 ,  1.28901781],
       [-0.43012094,  0.37535518,  0.70329552,  1.0470845 ],
       [-0.94949558, -0.74730953,  0.64814457,  0.81427752],
       [-0.82038604, -0.52695526, -0.28902625,  1.50346299],
       [-1.86214404, -0.0755429 ,  0.79078645,  0.95086558],
       [-1.06566936, -0.5175951 , -0.47628828,  0.74219896],
       [-1.22210946, -0.49192662,  1.00134016,  1.82552474],
       [-0.60213293,  0.00754592,  0.41291648,  0.44054662],
       [-0.95437149, -0.58423631,  0.16811405,  0.84229281],
       [-2.469909  , -1.21781935, -0.85420188,  0.42498577]])

행 방향으로 오룸차순

np.sort(single_arr,axis=0)

array([[-1.06566936, -1.22210946, -1.76115028, -2.469909  ],
       [-0.95437149, -0.98918133, -1.21781935, -1.86214404],
       [-0.85420188, -0.74730953, -0.58423631, -0.94949558],
       [-0.49192662, -0.60213293, -0.47628828, -0.82038604],
       [-0.2881095 , -0.52695526, -0.43012094, -0.5175951 ],
       [-0.0755429 ,  0.37535518, -0.28902625,  0.00754592],
       [ 0.41291648,  0.42498577,  0.43978861,  0.16811405],
       [ 0.70329552,  0.74219896,  0.44054662,  0.65941833],
       [ 0.81427752,  0.79078645,  0.64814457,  1.00134016],
       [ 1.37016394,  0.84229281,  0.95086558,  1.0470845 ],
       [ 1.50346299,  0.88699756,  1.82552474,  1.28901781]])

앞서 이용한 다차원 인덱싱을 응용하여 boolean 인덱싱을 할 수 있다.

주로 mask라고 얘기하는데, boolean 인덱싱을 통해 만들어낸 배열을 통해 원하는 행 또는 열의 값만 뽑아낼 수 있다.

즉, mask처럼 가리고 싶은 부분은 가리고 원하는 요소는 꺼낼 수 있다.

예를 살펴보자.

names=np.array(['kwan','lee','kyunh','koo','bae','yu','hyeong','ho','min','song','jin'])
names

array(['kwan', 'lee', 'kyunh', 'koo', 'bae', 'yu', 'hyeong', 'ho', 'min',
       'song', 'jin'], dtype='<U6')

names.shape
(11,)

문자열 배열을 생성하고,

ran_num=np.random.randn(11,4)
ran_num

array([[-0.59103603,  0.82348054, -0.29187746, -0.22239091],
       [-0.8100299 ,  0.84844129, -0.89056272, -0.56269183],
       [ 1.03756042, -1.27040716, -0.14321331, -1.29123492],
       [ 0.39628204, -1.18455294, -1.11007655, -0.25026466],
       [ 0.74178116, -1.39881718,  1.45385185,  1.7651273 ],
       [ 0.5388867 , -1.33991598,  0.82725191, -0.95091188],
       [ 1.77272678,  0.95240797, -0.94997094, -1.02506259],
       [-2.10105478, -0.47656731, -0.86786481, -1.54414126],
       [ 1.18391322, -0.82079135,  1.5303018 , -1.20934383],
       [-2.05976446, -2.59316339, -0.65387812,  0.52717579],
       [-0.48744984,  0.66963489,  0.69548501, -0.9389433 ]])
       
ran_num.shape

(11, 4)

숫자형 이차원 배열을 생성해준다.

np.random.randn() 함수는 기대값이 0, 표준편차가 1인 정규 분포를 따르는 난수 생성 함수이다.

np.random.rand() 함수는 0~1의 난수를 생성해주는 함수이다.

이제, names배열의 각 요소가 ran_num의 각 행과 연결된다고 가정해보자. 그렇기에 행을 맞춰 난수를 생성한 것이다.

이때, names가 'kwan'인 행의 요소들만 보고 싶을때 마스크를 사용한다.

names_kwan_mask=(names=='kwan')
names_kwan_mask

array([ True, False, False, False, False, False, False, False, False,
       False, False])

위는 요소가 'kwan'인 항목에 대한 mask를 생성한 것이다.

ran_num[names_kwan_mask,:]

array([[-0.59103603,  0.82348054, -0.29187746, -0.22239091]])

위 결과를 보면 'kwan'인 요소를 꺼내온다.

이를 위해 요소가 'kwan'인 것에 대한 boolean 값을 가지는 mask를 만들었고 마스크를 인덱싱에 응용하여 'ran_num'의 0행을 꺼냇다.

ran_num[names=='koo',:]

array([[ 0.39628204, -1.18455294, -1.11007655, -0.25026466]])

위는 요소가 'koo'인 행의 데이터만 꺼내온다.

ran_num[(names=='koo')|(names=='kwan'),:]

array([[-0.59103603,  0.82348054, -0.29187746, -0.22239091],
       [ 0.39628204, -1.18455294, -1.11007655, -0.25026466]])

위는 'names'의 요소가 'koo' or(|) 'kwan'인 행의 데이터만 꺼내온다.

물론 ran_num 배열 자체적으로도 마스크를 만들고, 이를 응용한 인덱싱이 가능하다. 

ran_num 배열에서 0번째 열의 값이 0보다 작은 행을 구해보자.

먼저 마스크를 만들어보자.

ran_num[:,0]<0

array([ True,  True, False, False, False, False, False,  True, False,
        True,  True])

위에서 만든 마스크를 이용해 0번째 열의 값이 0보다 작은 행을 구해보자.

ran_num[ran_num[:,0]<0,2:4]

array([[-0.29187746, -0.22239091],
       [-0.89056272, -0.56269183],
       [-0.86786481, -1.54414126],
       [-0.65387812,  0.52717579],
       [ 0.69548501, -0.9389433 ]])

다른 예로 0번째 열의 값이 0보다 작은 행의 2,3번째 열 값을 구해보자.

ran_num[ran_num[:,0]<0,2:4]=0
ran_num

array([[-0.59103603,  0.82348054,  0.        ,  0.        ],
       [-0.8100299 ,  0.84844129,  0.        ,  0.        ],
       [ 1.03756042, -1.27040716, -0.14321331, -1.29123492],
       [ 0.39628204, -1.18455294, -1.11007655, -0.25026466],
       [ 0.74178116, -1.39881718,  1.45385185,  1.7651273 ],
       [ 0.5388867 , -1.33991598,  0.82725191, -0.95091188],
       [ 1.77272678,  0.95240797, -0.94997094, -1.02506259],
       [-2.10105478, -0.47656731,  0.        ,  0.        ],
       [ 1.18391322, -0.82079135,  1.5303018 , -1.20934383],
       [-2.05976446, -2.59316339,  0.        ,  0.        ],
       [-0.48744984,  0.66963489,  0.        ,  0.        ]])

ML,DL에서도 masking이라는 개념이 있고, 위 boolean masking을 다시한번 공부하며 느낀 것이지만 아직도 쓰임이 어디에 잘 쓰이는지를 깨닫지는 못했다....;;

numpy에서 사용되는 인덱싱은 기본적으로 python 인덱싱과 동일하다.

이때, python에서와 같이 1번째로 시작하는 것이 아닌 0번째로 시작하는 것에 주의하자.

np_arr1=np.arange(10)
np_arr1

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

넘파이 배열을 생성했으니 반복문을 써서 처음부터 끝까지 인덱스를 호출해보자.

for index in range(len(np_arr1)):
    print(np_arr1[index], np_arr1)
    
0 [0 1 2 3 4 5 6 7 8 9]
1 [0 1 2 3 4 5 6 7 8 9]
2 [0 1 2 3 4 5 6 7 8 9]
3 [0 1 2 3 4 5 6 7 8 9]
4 [0 1 2 3 4 5 6 7 8 9]
5 [0 1 2 3 4 5 6 7 8 9]
6 [0 1 2 3 4 5 6 7 8 9]
7 [0 1 2 3 4 5 6 7 8 9]
8 [0 1 2 3 4 5 6 7 8 9]
9 [0 1 2 3 4 5 6 7 8 9]

직접 인덱스를 슬라이싱해보자.

np_arr1[3:5]

array([3, 4])

지정 인덱스부터 ':' 끝날 인덱스 라고 생각하는게 ':' 와 관련해서는 이해하기 좋다.

np_arr1[:]

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

단순히 ':' 만 적는다면 전체를 출력해준다.

여기서 주의할점은 이는 1차원 배열에서 사용되는 법이다. 

2차원 배열일때를 살펴보자.

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

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

np_arr2[0,1]
2

np_arr2[2,:]
array([ 9, 10, 11, 12])

np_arr2[2,2]
11

다음과 같이 2차원 배열에서 인덱싱을 하기 위해서는 2개의 인자를 입력해야 한다.

기본적으로 numpy에서 연산을 할때 크기가 서로 동일한 배열(Array)끼리 연산이 진행된다.

다음 예를 살펴보자.

우선 두개의 배열을 생성하자.

np_arr1=np.array([[1,2,3],[3,4,5]])
print(np_arr1)
print(np_arr1.shape)
np_arr2=np.array([[10,11,12],[12,13,14]])
print(np_arr2)
print(np_arr2.shape)

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

[[10 11 12]
 [12 13 14]]

(2, 3)

덧셈

np_arr1+np_arr2

array([[11, 13, 15],
       [15, 17, 19]])

뺄셈

np_arr1-np_arr2

array([[-9, -9, -9],
       [-9, -9, -9]])

곱셈

np_arr1*np_arr2

array([[10, 22, 36],
       [36, 52, 70]])

나눗셈

np_arr1/np_arr2

array([[0.1       , 0.18181818, 0.25      ],
       [0.25      , 0.30769231, 0.35714286]])

브로드캐스트(BroadCast)

위에서는 배열(Array)가 같은 크기를 가져야 서로 연산이 가능하다고 했다.

하지만 넘파이에서는 브로드캐스트라는 기능을 제공해준다.

브로드캐스트란 서로 크기가 다른 array가 연산이 가능하게끔 하는 것이다.

print(np_arr1)
print(np_arr1.shape)

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

np_arr3=np.array([10,11,12])
print(np_arr3)
print(np_arr3.shape)

[10 11 12]
(3,)

#덧셈 broadcast
np_arr1+np_arr3

array([[11, 13, 15],
       [13, 15, 17]])

#뺄셈 broadcast
np_arr1-np_arr3

array([[-9, -9, -9],
       [-7, -7, -7]])

#곱셈 boradcast
np_arr1*np_arr3

array([[10, 22, 36],
       [30, 44, 60]])
       
#나눗셈 broadcast
np_arr1/np_arr3

array([[0.1       , 0.18181818, 0.25      ],
       [0.3       , 0.36363636, 0.41666667]])

위와 같이 서로 shape가 다른 np_arr1,np_arr3의 연산이 가능하다.

위 결과를 살펴보면 np_arr3이 [10,11,12]에서 [[10,11,12],[10,11,12]]로 확장되어 계산됨을 확인할 수 있다.

또한 배열(Array)에 스칼라 연산도 가능하다.

np_arr1*10

array([[10, 20, 30],
       [30, 40, 50]])
       
np_arr1**10

array([[      1,    1024,   59049],
       [  59049, 1048576, 9765625]], dtype=int32)

Numpy에서 array를 정의할 때 사용되는 함수들이다. 

np.zeros()

np.zeros()함수는 인자로 받는 크기만큼 모든 요소가 0인 배열(Array)을 만든다.

np.zeros(10)

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

10을 인자로 받아 10개의 요소 0인 배열 생성

np.zeros((3,5))

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

(3,5)를 인자로 받아 3 by 5인 이차원 배열을 요소 0으로 만든다.

np.ones()

np.ones()함수는 인자로 받는 크기만큼, 모든 요소가 1인 배열(Array)을 만든다.

np.ones(9)

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

9를 인자로 받아 9개의 요소 1인 배열 생성

np.ones((3,5))

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

(3,5)를 인자로 받아 3 by 5인 이차원 배열을 요소 1로 만든다.

np.arange(10)

np.arange() 함수는 인자로 받는 값 만큼 1씩 증가하는 1차원 배열(Array)을 만든다. 

np.arange(10)

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

하나의 인자만 입력하면 0부터 입력한 인자까지 값만큼 받는다.

np.arange(3,10)

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

두개의 인자를 입력하면 첫 인자(3)부터 마지막 인자(10)까지의 배열을 생성한다.

머신러닝과 딥러닝에서 위 함수는 어떻게 쓰일까?

앞선 np.ones()와 np.zeros()는 레이블을 지정해줄 수 있다. 0혹은 1로

또한, 인덱스를 추가할경우를 생각해보면 반복문을 통해 데이터에 인덱스를 부여하는 것은 비효율적이다.

차라리 np.arange(data_len)을 통해 한번에 인덱스를 배열에 추가한다음 데이터프레임으로 옮겨주는게 더 효과적일 것이다.