불굴의관돌로그

후방이동(backshift)

후방이동(backshift) 연산자 B는 시계열 시차를 다룰 때 유용한 표기법 장치이다.

(참고 문헌에서는 '후방이동(backshift)'을 나타내는 B 대신에 '시차(lag)'을 나타내는 L을 사용한다.)

다르게 말하면, y(t)에 작용하는 B는 데이터를 한 시점 뒤로 옮기는 효과를 낸다. B를 y(t)에 두 번 적용하면 데이터를 두 시점 뒤로 옮긴다.

월별 데이터에서, '지난해와 같은 달' 을 다루고 싶다면, 다음과 같이 표기한다.

후방이동(backshift)연산자는 차분을 구하는 과정을 설명할 때 편리하다. 1차 차분을 다음과 같이 쓸 수 있다.

1차 차분을 (1-B)로 나타냈다는 것에 주목해보자. 비슷하게, 2차 차분을 계산해야하면, 이 때는 아래와 같이 주어진다.

일반적으로, d차 차분은 다음과 같이 쓸 수 있다.

차분을 연산자로 결합하면 보통의 대수 법칙을 사용하여 다룰 수 있게 되기 때문에, 후방이동(backshift) 기호는 특별히 유용하다. B를 포함하는 항은 서로 곱할 수 있다.

예를 들면, 1차 차분 뒤에 이어서 나오는 계절성 차분은 다음과 같이 쓸 수 있다.

이는 이전에 얻은 결과와 같다.

ARIMA 모형은 대표적인 통계적 시계열 예측 모형으로, 현재 값을 과거 값과 과거 예측 오차를 통해 설명한다. 이 모형을 적합하려면 시계열 Yt가 정상성 조건을 만족하는 정상 시계열(Stationary series)이어야 한다. (정확하게는 약정상성, weak stationary). 또한, 주어진 시계열 자료에 적합한 ARIMA(p,d,q)를 결정하는 절차는 Box-Jenkins method를 따르며, ACF(Autocorrelation function: 자기상관함수)로 시계열의 특성을 파악하고 적절한 차수의 ARIMA 모형을 선택한다.

정상성(Stationary)

우리는 시간의 순서에 따라 기록되지 않은 일반적 자료들을 분석할 때, Random sample들에 iid가정을 한다. 

*iid: All samples are independent and identically distributed

시간에 종속되어있는 시게열은 상식적으로 iid 가정을 할 수 없다. 그래서 이러한 시계열 자료에 대해 예측 모형을 적합하고 통계적 검정을 하기 위해서는 분석을 단순화 시킬 수 있는 새로운 가정이 필요하다. 

이중 가장 중요한 것이 시계열 모형의 확률적 성질이 시간에 따라 변하지 않는다고 가정하는 정상성 가정이다.

ARIMA모형은 해당 시계열이 약정상성(Weak Stationary)를 만족한다고 가정하며, 약정상성을 만족해야 좋은 fitting과 predict 성능을 보여줄 수 있다. 시계열 Yt가 다음의 세 조건을 만족할 때 약정상성을 가진다고 표현한다. 시계열 분서겡서 말하는 정상 시계열(Stationary series)은 약 정상성을 가지는 시계열을 말한다.

-평균이 모든 시점 t에서 동일하다 : 추세, 계절성, 순환성 등의 패턴이 보이지 않게 된다.

-분산이 모든 시점 t에서 동일하다: 자료 변화의 폭이 일정하게 된다.

-Yt와 Y(t-h) 간의 Covariation(즉, Yt의 자기 공분산 함수)이 모든 시점 t에 대해서 동일하다: 시간에 따라 상이한 자기상관적 패턴을 보이지 않게 된다.

즉, 풀어설명하자면 추세와 계절성이 있는 시계열은 정상성을 나타내는 시계열이 아니다. 일반적으로 정상성을 나타내는 시계열은 장기적으로 볼 때 예측할 수 있는 패턴을 나타내지 않을 것이다. (어떤 주기적인 행동이 있을 수 있더라도) 시간 그래프는 시계열이 일정한 분산을 갖고 대략적으로 평평하게 될 것을 나타낼 것이다.

그렇다면 다음 시계열 그래프중 어떤 것이 정상성을 나타낼까? 

a) 거래일 200일 동안의 구글 주식 가격

b) 거래일 200일 동안의 구글 주식 가격의 일일 변동

c) 미국의 연간 파업 수

d) 미국에서 판매되는 새로운 단독 주택의 월별 판매액

e) 미국에서 계란 12개의 연간 가격(고정 달러)

f) 호주 빅토리아 주에서 매월 도살한 돼지의 전체 수

g) 캐나다 북서부 맥킨지 강 지역에서 연간 포획된 시라소니의 전체 수

h) 호주 월별 맥주 생산량

i) 호주 월별 전기 생산량

분명하게 계절성이 보이는 d),h),i)는 후보가 되지 못한다. 추세가 있고 수준이 변하는 a),c),e),f),i)도 후보가 되지 못한다. 분산이 증가하는 i)도 후보가 되지 못한다. 그렇다면 b)와 g)만 정상성을 나타내는 시계열 후보로 남았다.

얼핏 보면 시계열 g)에서 나타나는 뚜렷한 주기(cycle)때문에 정상성을 나타내는 시계열이 아닌 것처럼 보일 수 있다. 하지만 이러한 주기는 불규칙적(aperiodic)이다. 

즉, 먹이를 구하기 힘들만큼 시라소니 개체수가 너무 많이 늘어나 번식을 멈춰서, 개체수가 작은 숫자로 줄어들고, 그 다음 먹이를 구할 수 있게 되어 개체수가 다시 늘어나는 식이다. 

장기적으로 볼 때 , 이러한 주기의 시작이나 끝은 예측할 수 없다. 따라서 이 시계열은 정상성을 나타내느 시계열이다.

차분(differencing)

처음 그림에서 패널(a) 의 구글 주식 가격이 정상성을 나타내는 시계열이 아니었지만 (b)의 일별 변화는 정상성을 나타냈다느 것에 주목해보자. 이 그림은 정상성을 나타내지 않는 시계열을 정상성을 나타내도록 만드는 한 가지 방법을 나타낸다.

연이은 관측값들의 차이를 계산하는 것이다. 이를 차분(differencing)이라 부른다.

로그변환은 시계열의 분산 변화를 일정하게 만드는데 도움이 될 수 있다. 차분(differencing)은 시계열의 수준에서 나타내느 변화를 제거하여 시계열의 평균 변화를 일정하게 만드는데 도움이 될 수 있다. 결과적으로 추세나 계절성이 제거(또는 감소) 된다.

정상성을 나타내지 않는 시계열을 찾아낼 때 데이터의 시간 그래프를 살펴보는 것만큼, ACF 그래프도 유용하다. 정상성을 나타내지 않는 데이터에서는 ACF가 느리게 감소하지만, 정상성을 나타내는 시계열에서는, ACF가 비교적 빠르게 0으로 떨어질 것이다. 그리고 정상성을 나타내지 않는 데이터에서 r1은 종종 큰 양수 값을 갖는다.

차분을 구한 구글 주식 가격의 ACF는 단순히 white noise 시계열처럼 생겼다. 95% limitation 바깥에 자기상관(autocorrelation)값이 없고, 융-박스(Ljung-Box) Q* 통계는 h=10 에 대해 0.355라는 p-value를 갖는다. 이 결과는 구글 주식 가격의 일별

Box.test(diff(goog200), lag=10, type="LJung-Box")

#Box-Ljung test

#data: diff(goog200)
#X-Squared=11, df=10, p-value=0.4

변동이 기본적으로는 이전 거래일의 데이터와 상관이 없는 무작위적인 양이라는 것을 말해준다.

확률보행 모델

차분(difference)을 구한 시게열은 원래의 시계열에서 연이은 관측값의 차이이고, 다음과 같이 쓸 수 있다.

첫 번째 관측값에 대한 차분 y'1을 계산할 수 없기 때문에 차분을 구한 시계열은 T-1개의 값만 가질 것이다.

차분을 구한 시계열이 white noise이면, 원래 시계열에 대한 모델은 다음과 같이 쓸 수 있다.

여기서 Error(t)는 white noise를 의미한다. 이것을 정리하면 '확률보행(random walk)' 모델을 얻는다.

확률보행(random walk) 모델은 정상성을 나타내지 않은 데이터, 특별히 금융이나 경제 데이터를 다룰 때 널리 사용되고 있다. 확률보행에는 보통 다음과 같은 특징을 가진다.

-누가 봐도 알 수 있는 긴 주기를 갖는 상향 또는 하향 추세가 있다.

-갑작스럽고 예측할 수 없는 방향 변화가 있다.

미래 이동을 예측할 수 없고 위로 갈 확률이나 아래로 갈 확률이 정확하게 같기 때문에 확률보행 모델에서 얻어낸 예측값은 마지막 관측값과 같다. 따라서, 확률보행 모델은 단순(naive) 예측값을 뒷받침한다.

밀접하게 연관된 모델은 차분값이 0이 아닌 평균값을 갖게 한다. 그러면,

c값은 연이은 관측값의 차이의 평균이다. c가 양수이면, 평균 변화는 y(t)값에 따라 증가한다. 따라서 y(t)는 위쪽 방향으로 이동하는 경향을 나타낼 것이다. 하지만 c가 음수이면, y(t)는 아래쪽 방향으로 이동하는 경향을 나타낼 것이다.

2차 차분

가끔 차분(difference)을 구한 데이터가 정상성(stationarity)이 없다고 보일 수도 있다. 정상성을 나타내는 시계열을 얻기 위해 데이터에서 다음과 같이 한 번 더 차분을 구하는 작업이 필요할 수 있다.

이 경우에는, y(t)''는 T-2개의 값을 가질 것이다. 그러면, 원본 데이터의 '변화에서 나타나는 변화'를 모델링하게 되는 셈이다. 실제 상황에서는, 2차 차분 이상으로 구해야 하는 경우는 거의 일어나지 않는다.

계절성 차분

계절성 차분(seasonal differencing)은 관측치와, 같은 계절의 이전 관측값과의 차이를 말한다. 따라서

여기에서 m은 계절의 개수이다. m 주기 시차 뒤의 관측을 빼기 때문에 시차 m 차분이라고 부르기도 한다.

계절성으로 차분을 구한 데이터가 white nois로 보이면, 원본 데이터에 대해 적절한 모델은 다음과 같다.

이 모델에서 낸 예측값은 관련 있느 계절의 마지막 관측값과 같다. 즉, 이 모델은 계절성 단순(seasonal naive) 예측값을 나타낸다.

위 그림의 아래쪽 패널은 호주에서 팔린 A10 약물(당뇨병 약)의 월별 처방전의 수에 로그를 취하여 계절성 차분을 구한 결과를 나타낸다. 변환과 차분을 통해 시계열이 정상성을 나타내는 것처럼 보인다.

cbind("판매량 (백만 달러)"= a10, 
	  "월별 로그 판매량"= log(a10), 
      "로그 눈금에서 연간 변동"=diff(log(a10),12))%>%
  autoplot(facets=TRUE)+
  	xlab("연도")+ylab("")+
    ggtitle("당뇨병 약 판매량")

보통의 차분과 계절성 차분을 구분하기 위해, 때때로 보통의 차분을 시차 1에서 차분을 구한다는 의미로 "1차 차분(first difference)"라고 부른다. 

위 그림에서 나타낸 것처럼, 계절성을 나타내는 데이터를 얻기 위해 계절성 차분과 1차 차분 둘 다 구하는 것이 필요하기도 한다. 여기서는 데이터를 먼저 로그로 변환하고(두번째 패널), 그 후 계절성 차분을 계산했다(세번째 패널). 데이터에서 여전히 정상성이 보이지 않는 것 같아서, 1차 차분을 더 많이 계산했다.

cbind("10억 kWh" = usmelec,
      "로그" = log(usmelec),
      "계절성\n 차분 로그값" =
        diff(log(usmelec),12),
      "두 번\n 차분을 구한 로그값" =
        diff(diff(log(usmelec),12),1)) %>%
  autoplot(facets=TRUE) +
    xlab("연도") + ylab("") +
    ggtitle("미국 월별 순 전기 생산량")

어떤 차분(difference)을 구할지 정할 때는 주관적인 요소가 어느정도 들어간다. 위 약물 그림의 계절성 차분(seasonal difference)을 구한 데이터는 월별 순 전기 생산량의 계절성 차분을 구한 데이터와는 큰 차이를 나타내지 않는다. 후자의 경우, 계절성 차분을 구한 데이터로 결정했어야 했고, 차분을 더 구하지 않아도 되었다. 이에 반면해 전자의 경우에는 데이터의 정상성(stationarity)이 충분히 나타나지 않아서 차분을 더 구해야 했다. 차분을 구하는 것에 대한 몇가지 형식적인 검정을 아래에서 다루지만, 모델링 과정에서 항상 몇 가지 선택이 존재하고, 분석하는 사람마다 다른 선택을 할 수 있다.

y'(t)=y(t)-y(t-m)가 계절성 차분(seasonal difference)을 구한 시계열을 나타낸다면, 두 번 차분한 시계열은 다음과 같다.

계절성 차분과 1차 차분을 둘 다 적용할 때, 어떤 것을 먼저 적용하더라도 차이는 없다. 결과는 같을 것이다. 하지만, 데이터에 계절성 패턴이 강하게 나타나면, 계절성 차분을 먼저 계산하는 것을 추천한다. 왜냐면, 때때로 결과 시계열에서 정상성이 나타나기도 해서 이런 경우 1차 차분을 구할 필요가 없게 되기 때문이다. 1차 차분을 먼저 계산했다면, 여전히 남아있는 계절성이 나타날 것이다.

차분을 구했다면, 차분 값이 해석 가능할 것이라는 것은 중요하다. 첫 번째 차분값은 한 관측값과 그 다음 관측값 사이의 변화이다. 계절성 차분값은 한 해와 그 다음 해 사이의 변화이다. 다른 시차값(lagged value)은 직관적으로 해석하기가 쉽지 않기 때문에 사용하지 않는 것이 좋다.

단위근검정

단위근검정(unit root tests)은 더 객관적으로 차분을 구하는 것이 필요할 지 결정하기 위해 사용하는 한 가지 방법이다. 차분을 구하는 것이 필요한지 결정하는 상황을 위해 설계된 통계적 가설 검정들이 존재한다. 사용할 수 있는 단위근검정은 다양하고, 서로 다른 가정에 기초하고 있으며, 상반되는 답을 낼 수도 있다. 분석 과정에서 KPSS(Kwiatkowski-Phillips-Schmidt-Shin)검정을 사용한다. 이 검정은 데이터에 정상성이 나타난다는 것이 귀무가설이고, 귀무 가설이 거짓이라는 증거를 찾으려고 한다. 결과적으로 ,작은 p-value는 차이를 구하는 것이 필요하다는 것을 나타낸다. 검정은 다음과 같다.

예로는 구글 주식 가격 데이터에 적용해보자.

library(urca)
goog %>% ur.kpss() %>% summary()
#> 
#> ####################### 
#> # KPSS Unit Root Test # 
#> ####################### 
#> 
#> Test is of type: mu with 7 lags. 
#> 
#> Value of test-statistic is: 10.72 
#> 
#> Critical value for a significance level of: 
#>                 10pct  5pct 2.5pct  1pct
#> critical values 0.347 0.463  0.574 0.739

검정 통계량은 1% 임계값보다 훨씬 크다. 이것은 귀무가설이 기각 된다는 것을 의미한다. 즉, 데이터가 정상성을 가지고 있지 않다. 데이터에 차분을 수행할 수 있고 검정을 다시 적용할 수 있다.

goog %>% diff() %>% ur.kpss() %>% summary()
#> 
#> ####################### 
#> # KPSS Unit Root Test # 
#> ####################### 
#> 
#> Test is of type: mu with 7 lags. 
#> 
#> Value of test-statistic is: 0.0324 
#> 
#> Critical value for a significance level of: 
#>                 10pct  5pct 2.5pct  1pct
#> critical values 0.347 0.463  0.574 0.739

이번에는 검정 통계가 작고(0.0324), 정상성이 나타나는 데이터에서 볼 수 있는 것처럼 범위 안에 잘 들어간다. 따라서 차분을 구한 데이터가 정상성을 나타낸다고 결론내릴 수 있다.

1차 차분의 적당한 횟수를 결정하기 위해 여러번의 KPSS 검정을 사용하는 이 과정을 ndiffs()로 수행할 수 있다.

ndiffs(goog)
#> [1] 1

위 검정들에서 본 것처럼, google데이터가 정상성을 나타내도록 하려면 한번의 차분(difference)이 필요하다.

계절성 차분(seasonal difference)이 필요한지 결정하기 위한 비슷한 함수는 nsdiffs()이다. 이 함수는 필요한 계절성 차분의 적당한 횟수를 결정하기 위해 계절성 강도 측정량을 사용한다. Fs<0.64이면, 계절성 차분이 필요 없다고 알려주고, 이외의 경우에는 하나의 계절성 차분이 필요하다 알려준다.

시계열 예측(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)을 통해 한번에 인덱스를 배열에 추가한다음 데이터프레임으로 옮겨주는게 더 효과적일 것이다.

Numpy란

Numpy는 C언어를 기반으로 구현된 파이썬 라이브러리로써, 고성능 수치계산을 위해 제작되었다.

Numerical Python의 줄임말이기도 한 Numpy는 벡터 및 행렬 연산에 있어 매우 편리한 기능을 제공해준다.

Numpy는 기본적으로 배열(Array)로 데이터를 관리하며 이에 대해 연산을 수행한다. 

코딩을 통해 살펴보자.

#numpy 모듈 불러오기
import numpy
#단축어로 불러오기
import numpy as np

위는 기본적인 내용이므로 생략.

#Array 정의 및 사용

data_1=[1,2,3,4,5]
data_2=[1,2,3,4,4.5,6,7]
print(data_1,data_2)

[1, 2, 3, 4, 5] [1, 2, 3, 4, 4.5, 6, 7]

단순히 배열을 생성한다.

#numpy를 이용한 array 정의
#단순 리스트 numpy array로 사용
np_arr1=np.array(data_1)
print(np_arr1)
#array의 형태(크기)를 확인하는 메서드.
print(np_arr1.shape)

[1 2 3 4 5]
(5,)

넘파이에서의 형태출력은 보통 이차원 배열로 출력해준다. 그렇기에 (5,)으로 출력된다.

#직접 numpy array 선언
np_arr2=np.array([1,2,3,4,5])
print(np_arr2)
#array의 형태(크기)를 확인하는 메서드.
print(np_arr2.shape)
#array의 자료형 확인 메서드.(dtype: datatype 약자)
print(np_arr2.dtype)

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

dtype를 통해 integer임을 확인할 수 있다.

np_arr3=np.array(data_2)
print(np_arr3)
print(np_arr3.dtype)

[1.  2.  3.  4.  4.5 6.  7. ]
float64

dtype을 통해 float을 확인할 수 있다.

np_arr4=np.array([[1,2,3],[3,4,5],[5,6,7],[7,8,9]])
print(np_arr4)
print(np_arr4.shape)

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

이차원 배열을 정의한 후, 형태까지 확인해본 결과이다. 

numpy shape

numpy에서는 해당 array의 크기를 알 수 있다.

shape 을 확인함으로써 몇개의 데이터가 있는지, 몇 차원으로 존재하는지 등을 확인할 수 있다.

위에서 arr1.shape의 결과는 (5,) 으로써, 1차원의 데이터이며 총 5라는 크기를 갖고 있음을 알 수 있다.

arr4.shape의 결과는 (4,3) 으로써, 2차원의 데이터이며 4 * 3 크기를 갖고 있는 array 이다.

numpy 자료형

arr1이나 arr2는 int64라는 자료형을 갖는 것에 반해 arr3는 float64라는 자료형을 갖는다.

이는 arr3내부 데이터를 살펴보면 3.5라는 실수형 데이터를 갖기 때문임을 알 수 있다.

numpy에서 사용되는 자료형은 아래와 같다. (자료형 뒤에 붙는 숫자는 몇 비트 크기인지를 의미한다.)

• 부호가 있는 정수 int(8, 16, 32, 64)
• 부호가 없는 정수 uint(8 ,16, 32, 54)
• 실수 float(16, 32, 64, 128)
• 복소수 complex(64, 128, 256)
• 불리언 bool
• 문자열 string_
• 파이썬 오프젝트 object
• 유니코드 unicode_

배열(Array)의 특징

-같은 자료형을 가진 변수를 하나로 나타낸 것이다.

-연속된 메모리 공간으로 이루어져있다.

-정적 표현이다.

-인덱스를 이용하여 표현한다.

-지역성을 갖고 있다.

배열(Array)의 장점

-인덱스를 통한 검색이 용이하다.

-연속적이므로 메모리 관리가 편하다.

배열(Array)의 단점

-한 데이터를 삭제하더라도 배열은 연속해야 하므로 공간이 남는다. 즉 메모리 낭비를 한다.

-정적이므로 배열의 크기를 컴파일 이전에 정의해주어야 한다.

-컴파일 이후 배열의 크기를 변동 할 수 없다.

리스트(List)의 특징

-순서가 있는 데이터의 집합이다.

-불연속적으로 메모리 공간을 차지한다.

-동적표현이다.

-인덱스가 없다.

-포인터를 통한 접근을 한다.

리스트의 장점

-포인터를 통하여 다음 데이터의 위치를 가리키고 있어 Insert, Delete에 용이하다.

-동적이므로 크기가 정해져 있지 않다.

-메모리의 재사용이 편리하다.

-불연속적이므로 메모리 관리의 편리하다.

리스트의 단점

-검색 성능이 좋지 않다.

-포인터를 통해 다음 데이터를 가르키므로 추가적인 메모리 공간이 발생한다.

흔히 이는 C언어에서 많이 정의하는 내용이다. 하지만 파이썬은 List를 배열이라고 부른다.

이것은 단순한 용어의 혼동에 불과하다. 보통, 컴퓨터 공학에서 리스트는 위의 섹션에서 말한 리스트를 의미한다. 하지만 파이썬에서는 리스트라는 용어를 다르게 사용한다.

파이썬을 공부하면서 알아야 할 점 중 하나는 다음과 같다: 파이썬에서 리스트가 어떻게 작동하는지 내부를 들여다 보면, 파이썬의 리스트는 배열처럼 구현이 되어있다는 것이다 (여기서 처럼이라는 표현을 쓴 이유는 정확하게 말하자면 Dynamic Array이기 때문이다). 구체적으로 말하자면, 파이썬 리스트의 아이템들은 메모리 상의 연속적인 위치에 배치되며, 인덱스를 사용하여 접근이 가능하다.

내부를 들여다 보면, 파이썬의 리스트는 좀 더 많은 기능을 담고있다. 예를 들어, 리스트에 아이템을 추가하고 제거하는 append와 pop과 같은 메서드를 가지고 있다. 이런 메소드를 사용하여, 우리는 파이썬의 리스트를 스택처럼 활용할 수 있다.

기본적으로 자료구조를 공부할 때, pop이나 append와 같은 부가적인 메소드들의 사용은 지양해야한다. 이것들은 high-level 프로그래밍 언어의 기능일 뿐이며, 다른 언어에서는 지원하지 않는 경우도 있기 때문이다. 특정 언어와 관계없이 자료구조를 익히기 위해, 파이썬에서는 리스트를 단순 배열로만 생각하는 것이 좋다 (자료구조 공부할 때!).

정리해보자면:

• 파이썬의 리스트의 근본은 배열이지만, high-level한 기능들이 추가되어 있다.
• 자료구조를 공부할 때 파이썬의 리스트를 단순 배열로 취급한다.

판다스의 apply() 메서드의 기본 문법은 다음과 같다.

apply() 메서드는 pandas 객체에 열 혹은 행에 대해 함수를 적용하게 해주는 메서드이다.

DataFrame.apply(func,axis=0,raw=False,result_type=None,args=(),**kwds)

*func: 이 입력변수는 pandas 객체의 열이나 행에 적용할 함수를 입력받는다.

*axis:함수를 적용할 축을 지정한다.

 -Series에 적용할 경우에는 axis를 따로 지정해주지 않는다.

 -0 or 'index' 

  example) DataFrame.apply(func,axis=0),  DataFrame.apply(func,axis='index')

  :함수를 각 열(columns)에 따라 적용한다.

 -1 or 'index'

  example) 위와 동일

  :함수를 각 행(row)에 따라 적용한다.

*agrs: func에 입력되는 위치 입력변수를 입력받는다. 즉, iterable한 자료형을 입력받는다. (list,tuple등)

*kwds: func에 입력되는 키워드 입력변수를 입력받는다. ->키워드에 입력될 입력값의 mapping을 입력받는다.

우선 데이터프레임을 간단하게 만들어보자.

import pandas as pd
import numpy as np

df=pd.DataFrame([[4,9]]*3,columns=['A','B'])
df

df.apply(np.sqrt)

위 코드처럼 단순히 apply()메서드에 func를 지정하면 각 Series로 처리가 된다. 즉 Series에서도 셀 당 처리를 해준다.

df.apply(np.sum,axis=0)

A    12
B    27
dtype: int64

axis=0으로 지정해 주었을 경우, 위 정의처럼 각 column에 따라 적용한다. 

그러므로, A 와 B column에 대하여 전체 합을 처리해준다.

df.apply(np.sum,axis=1)

0    13
1    13
2    13
dtype: int64

axis=1로 지정해 주었을 경우, 위 정의처럼 각 row에 따라 적용한다.

그러므로 index별로 전체 합을 처리해준다.

lambda 함수를 적용한 응용 apply()

다음 예를 확인해보자.

df.apply(lambda x: [1,2],axis=1)

0    [1, 2]
1    [1, 2]
2    [1, 2]
dtype: object

위 코드를 살펴보면 lambda함수를 사용해 [1,2] 리스트 형식을 axis=1이라는 조건을 통해 각 row에 적용시킨다.

그러면 위 결과와 같이 Series의 결과를 얻게 된다.

df.apply(lambda x:[1,2],axis=1,result_type='expand')

위 코드를 살펴보면 lambda함수를 사용해 [1,2]의 리스트를, axis=1이라는 조건을 통해 각 row에 적용 시키는데, 위 예제와 다른점은 result_type='expand' 조건을 추가 적용했다. 

result_type = 'expand'를 전달하면 목록과 유사한 결과가 데이터 프레임의 열로 확장된다.

그러므로 column_name은 0과 1(default)로 지정되고 각 data만 expand(확장)된것을 확인할 수 있다.

df.apply(lambda x:pd.Series([1,2],index=['foo','bar']),axis=1)

위 코드를 살펴보면 lambda함수를 통해 각 [1,2]로 되어있는 시리즈를 생성하고, index=['foo','bar']을 지정해준다. 추가로 axis=1을 지정해 줌으로써 각 row에 적용시키는데 위와 같은 결과를 얻을 수 있다.

df.apply(lambda x:[1,2],axis=1,result_type='broadcast')

위 코드를 살펴보면 lambda 함수를 통해 리스트형식인 [1,2]를, axis=1을 지정해줌으로써, 각 row에 삽입해준다.

추가로 result_type = 'broadcast'를 전달하면 함수가 목록 형이든 스칼라이든 상관없이 동일한 모양 결과를 보장하고 축을 따라 브로드 캐스트한다. 결과 열 이름은 원본이된다.

*result_type이란 앞서 조건이라고 말했지만 명확히 정의하자면 매개변수(parameter)이다.

{'expand','reduce','broadcast','None'} 종류가 있으며 axis=1 즉, row에만 적용 가능하다. 

GRU 기법을 사용해 주제를 분류해보자.

앞선 GRU기법에 대한 포스팅은 조만간 하겠다.

우선 필요한 라이브러리를 불러오자.

import pandas as pd
import urllib.request
%matplotlib inline
import matplotlib.pyplot as plt
import re
from konlpy.tag import Okt
from tensorflow.keras.preprocessing.text import Tokenizer
import numpy as np
from tensorflow.keras.preprocessing.sequence import pad_sequences
import os
from tensorflow.keras.datasets import reuters
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense,LSTM,Embedding
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import load_model
from tensorflow.keras.layers import Embedding,Dense,GRU
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tqdm import tqdm

데이터를 불러오고,

train_data=pd.read_csv('C:/data/Bluehouse/train.csv',encoding='utf-8')
test_data=pd.read_csv('C:/data/Bluehouse/test.csv',encoding='utf-8')
sample_submission=pd.read_csv('C:/data/Bluehouse/sample_submission.csv',encoding='utf-8')

어떤 데이터인지 확인해보자.

우선 train_data부터.

[40000열*3행]

우선 인덱스와 real_index는 같지만(!?) 카테고리와 데이터는 정확하게 나왔다.

테스트 데이터를 살펴보면,

[5000열&2행]

위 데이터는 실제 청원의 대한 내용이다.

이제 train_data,test_data에 대한 전처리 및 불용어 처리를 시행해보자. 

앞서 설명했던 포스트처럼 불용어 처리할때, 개인의 dictionary를 사용하는게 좋다. 

여기서 주의점은 사용하는 용도에 따라 dictionary는 바뀌어야한다. 

train_data=train_data.dropna(how='any')
train_data['data']=train_data['data'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣]","")
test_data['data']=test_data['data'].str.replace('[^ㄱ-ㅎㅏ-ㅣ가-힣]','')
stopwords=['의','가','이','은','들','는','좀','질','걍','과','도','를','으로','자','에','와','한','하다','을','도', '는', '다', '의', '가', '이', '은', '한', '에', '하', '고', '을', '를', '인', '듯', '과', '와', '네', '들', '듯', '지', '임', '게','요','거','로','으로',
            '것','수','할','하는','제','에서','그','데','번','해도','죠','된','건','바','구','세']

가장 기본적인 전처리 작업 후, 본인이 애용하는 pykospacing을 사용해보자

from pykospacing import spacing
train_data['data']=train_data['data'].apply(spacing)
test_data['data']=test_data['data'].apply(spacing)

앞선 포스팅을 봤다면 알것이다. 이쯤되면 데이터 처리속도가 상당히 느려질 뿐더러 위 데이터 전처리 과정조차도 상당한 시간이 걸린다. 

이에 대해 전처리된 데이터를 저장하자.

import pickle
train_data.to_pickle("C:/data/Bluehouse/train_data.pkl")
test_data.to_pickle("C:/data/Bluehouse/test_data.pkl")

이제 자연어 처리를 해보자.

okt=Okt()
test_data['tokenized']=test_data['data'].apply(okt.morphs)
test_data['tokenized']=test_data['tokenized'].apply(lambda x:[item for item in x if item not in stopwords])
train_data['tokenized']=train_data['data'].apply(okt.morphs)
train_data['tokenized']=train_data['tokenized'].apply(lambda x:[item for item in x if item not in stopwords])

단어 집합의 크기와 회귀수 등 여러가지로 중요한 점을 파악해보자.

X_Train=train_data['tokenized'].values
X_Test=test_data['tokenized'].values
y_Train=to_categorical(train_data['category'])

tokenizer=Tokenizer()
tokenizer.fit_on_texts(X_Train)

threshold=2
total_cnt=len(tokenizer.word_index)
rare_cnt=0
total_freq=0
rare_freq=0

for key,value in tokenizer.word_counts.items():
    total_freq=total_freq+value
    if(value<threshold):
        rare_cnt=rare_cnt+1
        rare_freq=rare_freq+value
        
print("단어집합의 크기:",total_cnt)
print("등장 빈도가 %s번 이하인 회귀 단어의 수: %s"%(threshold-1,rare_cnt))
print("단어집합에서 회귀 단어의 비율:",(rare_cnt/total_cnt)*100)
print("전체 등장 빈도에서 회귀 단어 등장 빈도 비율:",(rare_freq/total_freq)*100)

단어집합의 크기: 133738
등장 빈도가 1번 이하인 회귀 단어의 수: 61680
단어집합에서 회귀 단어의 비율: 46.120025721933935
전체 등장 빈도에서 회귀 단어 등장 빈도 비율: 1.0407867591945446

단어집합의 크기는 1333738개 존재한다. 등장빈도가 threshold값인 2회 미만, 즉, 1회인 단어들은 집합에서 단어 집합에서 약 46퍼센트 차치한다. 실제로 훈련 데이터에서 등장빈도로 차지하는 비중은 매우 작은 수치인 1퍼센트 밖에 되지 않는다. 이 계산법 및 코드에 대해서는 차후 포스팅 하겠다.

vocab_size=total_cnt-rare_cnt+2
print("단어 집합의 크기:",vocab_size)

단어 집합의 크기: 72060

위 단어집합 크기를 사용해 토크나이징을 시행해보자.

tokenizer=Tokenizer(vocab_size,oov_token='OOV')
tokenizer.fit_on_texts(X_Train)
X_Train=tokenizer.texts_to_sequences(X_Train)
X_Test=tokenizer.texts_to_sequences(X_Test)

print(X_Test[:2])
print(X_Train[:2])

text_to_sequences메서드를 시행함으로써 다음 결과는 이러하다.

[[435, 49, 1075, 3863, 799, 113, 577, 8, 27, 265, 113, 436, 12, 2, 9, 413, 27, 926, 829, 15, 2790, 2917, 6420, 9, 435, 49, 192], [357, 684, 105, 5549, 303, 23, 357, 684, 105, 3131, 35906, 3641, 64, 5549, 298, 866, 5061, 3131, 298, 19646, 1087, 803, 2801, 36356, 64, 2591, 1146, 12988, 5447, 1226, 3131, 1411, 7766, 3077, 819, 16487, 236, 970, 3301, 400, 1769, 319, 4050, 670]]
[[14825, 406, 4960, 2644, 131, 129, 254, 527, 5118, 16, 340, 381, 42, 131, 17717, 1300, 4289, 4, 89, 16, 7791, 7, 714, 131, 54362, 125, 11, 6880, 746, 6010, 45, 10, 4248, 45, 38, 2644, 131, 169, 3, 16, 340, 381, 10, 13, 5494, 2183, 3145, 382, 14, 4062, 340, 41, 8, 2945, 2869, 7, 254, 527, 574, 894, 66, 1882, 14826, 65, 89, 648, 229, 197, 894, 174, 23799, 231, 129, 344, 2869, 719, 1302, 2828, 45, 24, 11852, 4885, 182, 522, 3934, 575, 3035, 522, 2080, 174, 892, 2253, 404, 20871, 3035, 41, 8, 141, 1019, 6829, 213, 61, 5119, 515, 594, 2612, 246, 39625, 2796, 1221, 2167, 5495, 62, 131, 58, 12, 2309, 246, 2796, 338, 7342, 25011, 20872, 10427, 11853], [22, 533, 158, 20078, 2529, 137, 506, 1858, 864, 17, 5, 442, 1949, 26428, 6, 127, 41, 2529, 672, 2529, 506, 183, 2182, 78, 151, 11173, 151, 8478, 167, 4455, 41, 22, 15, 137, 30057, 5825, 6197, 158, 10168, 3178, 31, 54363, 22, 159, 155, 1293, 2859, 2529, 506, 11173, 116, 158, 7046, 2529, 158, 506, 1725, 66, 2029, 22, 533, 4710, 2663, 31, 116, 41, 22, 1177, 136, 60, 11173, 338, 1177, 1737, 159, 17205, 199, 26, 328, 2014, 3707, 578, 698, 54364, 1293, 187, 1729, 3609, 31, 170, 10285, 4063, 54, 5579, 10556, 357, 86, 38, 22, 54365, 2529, 225, 806, 148, 842, 81, 60, 258, 7, 1284, 29, 214, 1228, 3]]

결과는 위와 같으며, 실제 각 단어마다 정수 인코딩을 시행함으로써 각 단어에 numbering을 한것이라 볼 수 있다.

그렇다면 청원의 평균 길이는 얼마나 될까?

흔히 이것을 패딩이라한다. 이는 앞선 포스트에서 찾아볼 수 있다.

print("청원의 최대 길이:",max(len(i) for i in X_Train))
print("청원의 평균 길이:",sum(map(len,X_Train))/len(X_Train))
plt.hist([len(s) for s in X_Train],bins=50)
plt.xlabel('length of samples')
plt.ylabel('number of samples')
plt.show()

청원의 최대 길이: 9005

청원의 평균 길이: 148.1867873574715

대략, 청원의 최대 길이는 9005이며 평균 150 길이정도 된다는 것을 그림 및 수치적으로 알 수 있다.

이제 category에 대한 labeling을 시행해보자.

Y_Train=to_categorical(train_data['category'])

def below_threshold_len(max_len,nested_list):
    cnt=0
    for s in nested_list:
        if(len(s)<=max_len):
            cnt+=1
    print("전체 샘플 중 길이가 %s 이하인 샘플의 비율: %s"%(max_len,(cnt/len(nested_list))*100))

최대 길이가 5000인 경우 몇 개의 샘플들을 온전히 보전할 수 있는지 확인해보자.

max_len=5000
below_threshold_len(max_len,X_Train)

전체 샘플 중 길이가 5000 이하인 샘플의 비율: 99.99249849969995

test용 청원은 99.99퍼센트가 5000이하의 길이를 가진다. 그러므로, 훈련용 리뷰의 길이를 5000으로 지정하겠다. 

X_Train=pad_sequences(X_Train,maxlen=max_len)
X_Test=pad_sequences(X_Test,maxlen=max_len)

이제 GRU기법을 통해 얼마나 category에 근접한지 확인해보자.

modeling에 대해서는 가장 간단한 기초이므로 생략하겠다. 이는 앞선 딥러닝 기초에 대한 포스팅을 읽기 바란다.

model=Sequential()
model.add(Embedding(vocab_size,100))
model.add(GRU(120))
model.add(Dense(3,activation='softmax'))

es=EarlyStopping(monitor='val_loss',mode='min',verbose=1,patience=4)
mc=ModelCheckpoint('best_blue_GRU.h5',monitor='val_acc',mode='max',verbose=1,save_best_only=True)

model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['acc'])
history=model.fit(X_Train,Y_Train,epochs=5,batch_size=32)

Epoch 1/5 1250/1250 [==============================] - 9332s 7s/step - loss: 0.4483 - acc: 0.8139 Epoch 2/5 1250/1250 [==============================] - 9820s 8s/step - loss: 0.2283 - acc: 0.9159 Epoch 3/5 1250/1250 [==============================] - 8772s 7s/step - loss: 0.1363 - acc: 0.9493 Epoch 4/5 1250/1250 [==============================] - 8487s 7s/step - loss: 0.0820 - acc: 0.9689 Epoch 5/5 1250/1250 [==============================] - 8341s 7s/step - loss: 0.0526 - acc: 0.9796

y_pred=model.predict_classes(X_Test)
sample_submission['category']=y_pred
sample_submission.to_csv('c:/data/Bluehouse/submission.csv',encoding='utf-8',index=False)

이후 제출을 함으로써 얼마나 정확성이 나오나 확인해보자.

여기서 알 수 있는점은 단순히 불용어처리 즉 dictionary를 얼마나 알차게 짯느냐, 또한 알고리즘을 LSTM으로 짯느냐 혹은 GRU기법을 짯는냐에 따라 정확도는 올라가고 내려간다는것을 알 수 있다. 본인이 이 포스팅을 짜기전에 불용어(stopwords)는 똑같이 지정하고,  기법만 다르게 해봤다. 무려 0.4퍼센트 차이가 난다. 그러므로 다시한번 느끼지만 NLP는 얼마나 사전작업을 치느냐가 관건이라고 생각한다.

Dacon에서 연습용으로 할 수 있는 것이다. 

import pandas as pd
import urllib.request
%matplotlib inline

import matplotlib.pyplot as plt
import re
from konlpy.tag import Okt
from tensorflow.keras.preprocessing.text import Tokenizer
import numpy as np
from tensorflow.keras.preprocessing.sequence import pad_sequences
import os
from tensorflow.keras.datasets import reuters
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense,LSTM,Embedding
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import load_model
from tqdm import tqdm

데이터 불러오기

train_data=pd.read_csv('d:/data/train.csv',encoding='utf-8')
test_data=pd.read_csv('d:/data/test.csv',encoding='utf-8')
sample_submission=pd.read_csv('d:/data/sample_submission.csv',encoding='utf-8')

결측치 제거 및 간단한 전처리

train_data=train_data.dropna(how='any')
train_data['data']=train_data['data'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","")
test_data['data']=test_data['data'].str.replace("[^ㄱ-ㅎㅏ-ㅣ가-힣 ]","")
stopwords= ['의','가','이','은','들','는','좀','잘','걍','과','도','를','으로','자','에','와','한','하다','을']

konlpy에서 okt라는 자연어처리 라이브러리 불러오기

okt=Okt()

훈련용 데이터에 대해 자연어 처리 및 불용어처리 

*tqdm에 대해서는 추후 포스팅 하겠다.

X_train=[]
for sentence,i in zip(train_data['data'],tqdm(range(len(train_data['data'])))):
    temp_X=[]
    temp_X=okt.morphs(sentence,stem=True)
    temp_X=[word for word in temp_X if not word in stopwords]
    X_train.append(temp_X) 

테스트용 데이터에 대해 자연어 처리 및 불용어처리

X_test=[]
for sentence in test_data['data']:
    temp_X=[]
    temp_X=okt.morphs(sentence,stem=True)
    temp_X=[word for word in temp_X if not word in stopwords]
    X_test.append(temp_X)

fit_on_texts() 메서드를 통해 문자데이터를 입력받아 리스트 형식으로 변환.

text_to_sequences() 메서드를 통해 단어들을 시퀀스형식으로 변환

tokenizer=Tokenizer()
tokenizer.fit_on_texts(X_train)

vocab_size=30000
tokenizer=Tokenizer(vocab_size)
tokenizer.fit_on_texts(X_train)
X_train=tokenizer.texts_to_sequences(X_train)
X_test=tokenizer.texts_to_sequences(X_test)

pad_sequences() 메서드를 통해 서로 다른 개수의 단어로 이루어진 문장을 같은 길이로 만들어주기 위해 패딩한다.

500자로 동일하게 맞춰준다.

max_len=500
X_train=pad_sequences(X_train,maxlen=max_len)
X_test=pad_sequences(X_test,maxlen=max_len)

to_categorical() 메서드를 통해 One-hot인코딩 시행

*One-hot encoding:10진 정수 형식을 특수한 2진 바이너리 형식으로 변환, 파라미터로 값에 크기만큼 0으로 된 배열을 만들고, 파라미터 값 위치에만 1(hot)을 넣어준다.

y_train=to_categorical(train['category'])

데이터 모델링

Sequential(): Sequential()모델은 각 레이어에 정확히 하나의 입력 텐서와 하나의 출력 텐서가 있는 일반 레이어 스택에 적합.

Sequential 모델은 다음의 경우에 적합하지 않습니다.

• 모델에 다중 입력 또는 다중 출력이 있습니다
• 레이어에 다중 입력 또는 다중 출력이 있습니다
• 레이어 공유를 해야 합니다
• 비선형 토폴로지를 원합니다(예: 잔류 연결, 다중 분기 모델)

언어의 벡터화를 위해 Word Embedding 시행

LSTM기법 사용(120 layer)

활성화 함수:softmax 

전체 compile: 손실함수는 'categorical_crossentrophy'  이는 레이블이 n개일때 사용한다. 2개일때는 'binary cross entrophy'를  사용한다.

model=Sequential()
model.add(Embedding(vocab_size,120))
model.add(LSTM(120))
model.add(Dense(3,activation='softmax'))

model.compile(loss='categorical_crossentrophy',optimizer='adam',metrics=['acc'])
history=model.fit(X_train,y_train,batch_size=128,epochs=15)

예측한 자료를 csv 파일로 내보내자.

y_pred=model.predict_classes(X_test)
sample_submission['category']=y_pred
sample_submission.to_csv('d:/data/submission.csv',encoding='utf-8',index=False)

1. 수학과 파이썬 복습

벡터와 행렬

신경망에서는 '벡터'와 '행렬'(또는 텐서)이 등장한다.

벡터: 크기와 방향을 가지고 있는 양

행렬: 매트릭스라고도 하는데 행렬의 가로 줄을 행, 세로 줄을 열이라고 함

위 그림처럼 1차원 배열로, 행렬은 2차원 배열로 표현할 수있다. 행렬에서 가로줄은 행 세로줄은 열이라고 한다.

[Note]

파이선으로 구현할 때 벡터를 '행벡터'로 취급할 경우, 벡터를 가로 방향 '행렬'로 변환해 사용하면 명확해진다. 예컨대 원소 수가 N개인 벡터라면 1*N 형상의 행렬로 처리한다.

행렬의 원소별 연산

코드를 통해 간단하게 살펴보자

W=np.array([[1,2,3],[4,5,6]])
X=np.array([[0,1,2],[3,4,5]])
print(W+X)
print(W*X)

[[ 1  3  5]
 [ 7  9 11]]
[[ 0  2  6]
 [12 20 30]]

BroadCast

넘파이의 다차원 배열에서는 형상이 다른 배열끼리도 연산할 수 있다. 코드로 살펴보자

A=np.array([[1,2],[3,4]])
print(A*10)

[[10 20]
 [30 40]]

A=np.array([[1,2],[3,4]])
b=np.array([10,20])
A*b

array([[10, 40],
       [30, 80]])

위 2번째 계산에서는 1차원 배열인 b가 2차원 배열 A와 형상이 같아지도록 '영리하게' 확장된다.

벡터의 내적과 행렬의 곱

2개의 벡터 X=(x1,x2,x3,....,xn) Y=(y1,y2,y3,...,yn)이 있다고 가정하자.

내적

X·Y=x1y1+x2y2+...+xnyn

벡터의 내적은 위와 같이 두 벡터에서 대응하는 원소들의 곱을 모두 더한 것이다.

행렬의 곱

위 그림처럼 행렬의 곱은 '왼쪽 행렬의 행벡터(가로방향)'와 '오른쪽 행렬의 열벡터(세로방향)'의 내적(원소별 곱의 합)으로 계산한다.

코드로 살펴보자

#벡터의 내적
a=np.array([1,2,3])
b=np.array([4,5,6])
np.dot(a,b)

32

#행렬의 곱
A=np.array([[1,2],[3,4]])
B=np.array([[5,6],[7,8]])
np.matmul(A,B)

array([[19, 22],
       [43, 50]])

*matmul은 matrix multiply의 약자

행렬 형상 확인

행렬이나 벡터를 사용해 계산할 때는 형상에 주의해야 한다. 

[Note] 행렬의 곱 등 행렬을 계산할 때는 형상 확인이 중요하다. 그래야 신경망 구현을 부드럽게 진행할 수 있다.

신경망의 추론

신경망 추론 전체 그림

이미 공부한 것이기에 간단하게 계산법과 그림만 보고 넘어가자. 위 그림은 fully-connected neural network 이다.

[첫번째 뉴런 계산(벡터)]

[첫번째 뉴련 계산(행렬)]

이를 간소하게 표현하면

*X: input h:hidden layer neuran W:weight b:bias

행렬의 곱에서는 대응하는 차원의 원소수가 같아야 한다고 했다. 

위 그림처럼 형상을 살펴보면 올바른 변환인지를 확인할 수 있다.

[Note]

행렬의 곱 계산에서는 행렬의 형상 확인이 중요하다. 형상을 보면 그 계산이 올바른 계산인지, 적어도 계산이 성립하는지를 확인할 수 있다.

위 그림처럼 형상확인을 통해 각 미니배치가 올바르게 변환되었는지를 알 수 있다.

코드로 실습해보면,

W1=np.random.randn(2,4) #가중치
b1=np.random.randn(4) #편향
x=np.random.randn(10,2) #입력
h=np.matmul(x,W1)+b1 
print(h)

[[ 0.35116155  0.94789119 -0.67386652 -0.65909502]
 [ 0.384877   -0.72901409  0.18267204  0.7529613 ]
 [ 0.20165288  0.13624162 -0.09941832  0.00564759]
 [ 1.32167646 -0.20576129 -0.99788172  0.41926761]
 [ 1.26638845 -0.1371531  -0.98095405  0.35541107]
 [ 1.58613619 -0.25255841 -1.2280294   0.48841506]
 [-0.50280274  2.07146982 -0.44627022 -1.69904766]
 [ 0.50183445  0.11793651 -0.37910997  0.05489936]
 [ 4.47713058 -3.74912125 -2.16138615  3.7510847 ]
 [-2.8574282   2.54573098  1.5723183  -2.36307749]]

*위 코드에서 마지막 줄에 편향 b1의 덧셈은 broadcast된다. b1의 형상은 (4,)이지만 자동으로 (10,4)로 복제되는 것.

위 코드는 fully-connected layer이며 변환은 선형변환이다. 

여기서 비선형 효과를 부여하는 것이 바로 활성화 함수이다. 

대표적인 예로 시그모이드함수를 사용하자.

활성화함수에 대해서는 이미 포스팅했으니 넘어가겠다.

undeadkwandoll.tistory.com/16?category=909256

지금까지 한 것을 종합하여 코딩으로 구현해보자.

import numpy as np

def sigmoid(x):
    return 1/(1+np.exp(-x))

x=np.random.randn(10,2)
W1=np.random.randn(2,4)
b1=np.random.randn(4)
W2=np.random.randn(4,3)
b2=np.random.randn(3)

h=np.matmul(x,W1)+b1
a=sigmoid(h)
s=np.matmul(a,W2)+b2

print(s)

[[ 1.37255171  3.33303451  0.51454931]
 [ 1.45573303  3.28327178  0.59098017]
 [ 1.66378388  2.76835385  0.05013013]
 [-0.01466047  2.41627885  0.00654713]
 [ 1.44857064  2.97941464  0.12383537]
 [ 1.07105157  3.19234836  0.20873783]
 [ 1.03450019  2.88402671  0.72500931]
 [ 0.95191827  3.17697541  0.52755519]
 [-0.14788331  2.33162532 -0.11776118]
 [ 1.16358013  3.10202918  0.73084865]]

계층으로 클래스화 및 순전파 구현

이제 신경망에서 하는 처리를 계층으로 구현해보자. 

완전연결계층: Affine계층으로 변환 활성화함수: Sigmoid 기본변환 메서드: forward()

구현 규칙:

-모든 계층은 forward()와 backward() 메서드를 가진다.

-모든 계층은 인스턴스 변수인 params와 grads를 가진다.

forward()와 backward()메서드는 각각 순전파와 역전파를 수행한다. params는 가중치와 편향 같은 매개변수를 담는 리스트이다. grads는 params에 저장된 각 매개변수에 대응하여, 해당 매개변수의 기울기를 보관하는 리스트이다.

이번에는 순전파만 구현할 것이므로 앞의 구현 규칙 중 다음 두 사항만 적용한다.

1. 각 계층은 forward() 메서드만 가진다.

2. 매개변수들은 params 인스턴스 변수에 보관한다.

코드를 통해 살펴보자.

import numpy as np

class Sigmoid:
    def __init__(self):
        self.params=[]
    def forward(self,x):
        return 1/(1+np.exp(-x))
    

class Affine:
    def __init__(self,W,b):
        self.params=[]
    def forward(self,x):
        W,b=self.params
        out=np.matmul(x,W)+b
        return out
    
    

위 두 클래스의 주 변환처리는 forward(x)가 담당한다.

Sigmoid 계층에는 학습하는 매개변수가 따로 없으므로 인스턴스 변수인 params는 빈 리스트로 초기화한다.

Affine 계층은 초기화될 때 가중치와 편향을 받는다. 즉, 가중치와 편향은 Affine 계층의 매개변수이며, 리스트인 params인스턴스 변수에 보관한다.

다음은 TwoLayerNet을 구현해보자.

class TwoLayerNet:
    def __init__(self,input_size,hidden_size,output_size):
        I,H,O=input_size,hidden_size,output_size
        
        #가중치와 편향 초기화
        W1=np.random.randn(I,H)
        b1=np.random.randn(H)
        W2=np.random.randn(H,O)
        b2=np.random.randn(O)
        
        #계층 생성
        self.layers=[Affine(W1,b1),Sigmoid(),Affine(W2,b2)]
        
        #모든 가중치를 리스트에 모은다
        self.params=[]
        for layer in self.layers:
            self.params +=layer.params
            
    def predict(self,x):
        for layer in self.layers:
            x=layer.forward(x)
            
        return x
    

x=np.random.randn(10,2)
model=TwoLayerNet(2,4,3)
s=model.predict(x)
print(s)

[[-1.63600236 -0.58829572  2.12459972]
 [-1.29363917 -0.62995628  2.00383472]
 [-2.18231262 -0.51745636  2.29597345]
 [-0.45702306 -0.56597897  1.78600372]
 [-1.63980911 -0.71859781  2.13101938]
 [-1.95776705 -0.89778093  2.23616852]
 [-1.31212998 -1.19684139  2.04171904]
 [-0.38606698 -0.6532667   1.78814915]
 [-0.96887503 -0.71086643  1.90366492]
 [-1.4403579  -0.96416926  2.07110086]]

이상으로 입력 데이터 x에 대한 점수(s)를 구할 수 있었다. 이처럼 계층을 클래스로 만들어두면 신경망을 쉽게 구현할 수 있다. 

자연어 처리에서 크롤링 등으로 얻어낸 corpus data가 필요에 맞게 전처리되지 않은 상태라면, 용도에 맞게 토큰화(tokenization) & 정제(cleaning) & 정규화(normalization)하는 일을 하게 된다. 

이중 토큰화에 대해 알아보자.

토큰화(tokenization): 주어진 코퍼스(corpus)에서 토큰(token)이라 불리는 단위로 나뉘는 작업(보통 의미있는 단위로 토큰을 정의한다)

1. 단어 토큰화(Word Tokenization)

토큰의 기준을 단어(word)로 하는 경우, 단어 토큰화(word tokenization)라고 한다. 

*단어(word)는 단어 단위 외에도 단어구, 의미를 갖는 문자열로도 간주되기도 한다.

input) Time is an illusion. Lunchtime double so!

위 입력으로부터 토큰화 작업을 시키면 다음과 같다.

output) 'Time', 'is', 'an', 'illusion', 'Lunchtime', 'double', 'so'

위 출력을 나타내기 위해, 구두점을 지운 뒤에 띄어쓰기(whitespace)를 기준으로 잘라냈다.(가장 기초)

보통 토큰화 작업은 단순히 구두점이나 특수문자를 전부 제거하는 정제(cleaning) 작업을 수행하는 것만으로 해결되지 않는다. 구두점이나 특수문자를 전부 제거하면 토큰의 의미를 잃어버리는 경우가 발생하기도 한다. 심지어 띄어쓰기 단위로 자르면 사실상 단어 토큰이 구분되는 영어와 달리, 한국어는 띄어쓰기만으로는 단어 토큰을  구분하기 어렵다.

2. 토큰화 중 생기는 선택의 순간

토큰화를 하다보면, 예상하지 못한 경우가 있어 토큰화의 기준을 생각해봐야 하는 경우가 발생한다. 물론, 이러한 선택은 해당 데이터를 가지고 어떤 용도로 사용할 것인가에 따라 그 용도에 영향이 없는 기준으로 정하면 된다.

ex) Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop.

" ' " 가 들어간 상황에서 Dont't 와 Jone's는 어떻게 토큰화할 수 있을까?

[Dont't, Dont t, Dont, Do n't, Jone's, Jone s, Jone, Jones]

원하는 결과가 나오도록 토큰화 도구를 직접 설계할 수 있겠지만, 기존에 공개된 도구들을 사용하였을 때의 결과가 사용자의 목적과 일치한다면 해당 도구를 사용할 수 있을 것이다. NLTK는 영어 코퍼스를 토큰화하기 위한 도구들을 제공한다.

word_tokenize를 사용한 예를 살펴보자.

from nltk.tokenize import word_tokenize

print(word_tokenize("Don't be fooled by the dark sounding name, Mr. Jone's Orpanage is as cheery as cheery goes for a pastry shop."))

['Do', "n't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', ',', 'Mr.', 'Jone', "'s", 'Orpanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop', '.']

word_tokenize는 Dont't 를 Do 와 n't로 불리하였으며, 반면 Jone's는 Jone과 's로 분리한 것을 확인할 수 있다.

wordPunctTokenizer를 사용한 예를 살펴보자

from nltk.tokenize import WordPunctTokenizer
print(WordPunctTokenizer().tokenize("Don't be fooled by the dark sounding name, Mr. Jone's Orpanage is as cheery as cheery goes for a pastry shop."))

['Don', "'", 't', 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', ',', 'Mr', '.', 'Jone', "'", 's', 'Orpanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop', '.']

WordPunctTokenizer는 구두점을 별도로 분류하는 특징을 갖고 있기 때문에, word_tokenize와 달리 Don't를 Don과 '와 t로 분리하였으며, 이와 마찬가지로 Jone's를 Jone과 '와 s로 분리한 것을 확인할 수 있다.

케라스 또한 토큰화 도구로서 text_to_word_sequence를 지원한다. 

text_to_word_sequence를 사용한 예를 살펴보자

from tensorflow.keras.preprocessing.text import text_to_word_sequence
print(text_to_word_sequence("Don't be fooled by the dark sounding name, Mr. Jone's Orphanage is as cheery as cheery goes for a pastry shop."))

["don't", 'be', 'fooled', 'by', 'the', 'dark', 'sounding', 'name', 'mr', "jone's", 'orphanage', 'is', 'as', 'cheery', 'as', 'cheery', 'goes', 'for', 'a', 'pastry', 'shop']

text_to_word_sequence는 기본적으로 모든 알파벳을 소문자로 바꾸면서 마침표나 컴마, 느낌표 등의 구두점을 제거한다. 하지만 어퍼스트로피는 보존하는 것을 볼 수 있다.

토큰화에서 고려해야할 사항

토큰화작업은 단순하게 코퍼스에서 구두점을 제외하고 공백 기준으로 잘라내는 작업이라 생각하면 안된다. 

이유는 다음과 같다.

1) 구두점이나 특수 문자를 단순 제외해서는 안된다.

코퍼스에 대한 정제 작업을 진행하다보면, 구두점 조차도 하나의 토큰으로 분류하기도 한다. 

이러한 점에 있어 해결법은 단어의 빈도수 확인 및 직접 확인을 통해 사전을 만들어주는 경우, 혹은 오픈소스로 되어있는 단어집을 사용하는 방법이 있다.

2) 줄임말과 단어 내에 띄어쓰기가 있는 경우.

토큰화 작업에서 종종 영어권 언어의 "'"는 압축된 단어를 다시 펼치는 역할을 하기도 한다.

사용 용도에 따라, 하나의 단어 사이에 띄어쓰기가 있는 경우도 하나의 토큰으로 봐야하는 경우가 있을 수 있다. 

3) 표준 토큰화 예제

표준으로 쓰이는 토큰화 방법 중 하나인 Peen Treebank Tokenization의 규칙을 알아보자.

Rule 1) 하이푼으로 구성된 단어는 하나로 유지.

Rule 2) dont't 와 같이 아포스토로피가 함께하는 단어는 분리해준다.

예를 살펴보자.

input) "Starting a home-based restaurant may be an ideal. it doesn't have a food chain or restaurant of their own."

from nltk.tokenize import TreebankWordTokenizer
tokenizer=TreebankWordTokenizer()
text="Starting a home-based restaurant may be an ideal. it doesn't have a food chain or restaurant of their own"
print(tokenizer.tokenize(text))

['Starting', 'a', 'home-based', 'restaurant', 'may', 'be', 'an', 'ideal.', 'it', 'does', "n't", 'have', 'a', 'food', 'chain', 'or', 'restaurant', 'of', 'their', 'own']

결과는, 각 Rule1)과 Rule2)에 따라 home-based는 하나의 토큰으로 취급하고 있으며, doesn't의 경우 does와 n't로 분리되었음을 볼 수 있다.

4. 문장 토큰화(Sentence Tokenization)

대부분 갖고있는 코퍼스가 정제되지 않은 상태라면, 코퍼스는 문장 단위로 구분되어있지 않을 가능성이 높다.

이를 사용하고자 하는 용도에 맞게 하기 위해서는 문장 토큰화가 필요할 수 있다.

어떤 기준으로 문장을 나누어야할까? 코퍼스가 어떤 국적의 언어인지, 또는 해당 코퍼스 내에서 특수문자들이 어떻게 사용되고 있는지에 따라서 직접 규칙을 정의해야 한다. 이는 또한 100%의 정확성을 얻는 것은 아니다. 

NLTK에서는 영어 문장의 토큰화를 수행하는 sent_tokenize를 지원한다.

코드로 살펴보자.

from nltk.tokenize import sent_tokenize
text="His barber kept his word. But keeping such a huge secret to himself was driving him crazy. Finally, the barber went up a mountain and almost to the edge of a cliff. He dug a hole in the midst of some reeds. He looked about, to make sure no one was near."
print(sent_tokenize(text))

['His barber kept his word.', 'But keeping such a huge secret to himself was driving him crazy.', 'Finally, the barber went up a mountain and almost to the edge of a cliff.', 'He dug a hole in the midst of some reeds.', 'He looked about, to make sure no one was near.']

위 코드는 text에 저장된 여러 개의 문장들로부터 문장을 구분하는 코드이다. 

이번에는 마침표가 여러번 등장하는 경우를 살펴보자.

from nltk.tokenize import sent_tokenize
text="I am actively looking for Ph.D. students. and you are a Ph.D student."
print(sent_tokenize(text))

['I am actively looking for Ph.D. students.', 'and you are a Ph.D student.']

NLTK는 단순히 마침표를 구분자로 하여 문장을 구분하지 않았기 때문에, ph.D.를 문장 내의 단어로 인식하여 성공적으로 인식하는 것을 볼 수 있다.

한국어 문장 토큰화 도구 KSS(Korean Sentence Splitter)

import kss

text="대부분 갖고있는 코퍼스가 정제되지 않은 상태라면, 코퍼스는 문장 단위로 구분되어있지 않을 가능성이 높다.이를 사용하고자 하는 용도에 맞게 하기 위해서는 문장 토큰화가 필요할 수 있다."
print(kss.split_sentences(text))

['대부분 갖고있는 코퍼스가 정제되지 않은 상태라면, 코퍼스는 문장 단위로 구분되어있지 않을 가능성이 높다.', '이를 사용하고자 하는 용도에 맞게 하기 위해서는 문장 토큰화가 필요할 수 있다.']

5. 토큰화가 어려운 한국어

한국어는 띄어쓰기가 되어있는 단어를 '어절'이라 한다. 어절 토큰화는 NLP에서 지양되고 있다. 어절 토큰화와 단어 토큰화가 같지 않기 때문인데, 그 근본적인 이유는 한국어가 영어와는 다르게 다른 형태를 가지는 언어인 교착어라는 점에서 기인한다.

교착어: 언어의 형태적 유형의 하나. 실질적인 의미를 가진 단어 또는 어간에 문법적인 기능을 가진 요소가 차례로 결합함으로써 문장 속에서의 문법적인 역할이나 관계의 차이를 나타내는 언어로, 한국어ㆍ터키어ㆍ일본어ㆍ핀란드어 따위가 여기에 속한다.

자연어 처리를 하다보면 같은 단어여도 서로 다른 조사가 붙어 다른 단어로 인식이 되는 경우가 많다. 대부분 한국어 NLP에서 조사는 분리해줄 필요가 있다.

한국어 토큰화에서는 형태소(morpheme)란 개념을 반드시 알아야 한다.

형태소: 단어를 분석한 단위로, 뜻을 가진 가장 작은 말의 단위

또한 한국어는 띄어쓰기가 영어보다 잘 지켜지지 않는다.

대부분의 한국어 경우 띄어쓰기가 틀렸거나, 잘 지켜지지 않은 코퍼스가 많다. 한국어는 영어권 언어와 달리 띄어쓰기가 어렵고 잘 지켜지지 않는 경향이 있다.

하지만, 실제로 잘 이루어지지 않더라도 이해가 가능한것이 또 한국어이다.

[한국어]

지금이렇게띄어쓰기를안한다해도이해못하는사람없겠죠?

[영어]

Itisdifficulttounderstandenglishbecauseitdidn'tsplitsentence

이 차이는 한국어(모아쓰기 방식)와 영어(풀어쓰기 방식)라는 언어적 특성의 차이 때문이다.

합성곱/풀링 계층 구현하기

4차원 배열

앞선 포스팅에서 설명한대로 CNN에서 계층 사이를 흐르는 데이터는 4차원이다. 파이썬으로 구현해보자.

import numpy as np

x=np.random.rand(10,1,28,28)
x.shape

(10, 1, 28, 28)

*첫번째 데이터에 접근하려면 단순히 x[0]이라고 쓴다(파이썬의 인덱스는 0부터 시작한다).

x[0].shape #(1,28,28)
x[1].shape #(1,28,28)

*또, 첫 번째 데이터의 첫 채널의 공간 데이터에 접근하려면 다음과 같이 구현한다.

x[0,0].shape #또는 x[0][0]

im2col로 데이터 전개하기

합성곱 연산을 곧이곧대로 구현하려면 for 문을 겹겹이 써야한다. 하지만 넘파이에 for문을 사용하면 성능이 떨어지는 단점이 있다.(넘파이에서는 원소에 접근할 때 for문을 사용하지 않는 것이 바람직하다).

그렇기에 for 문 대신 im2col이라는 편의 함수를 사용해 간단하게 구현해보자.

im2col은 입력 데이터를 필터링(가중치 계산)하기 좋게 전개하는 함수이다. 위 그림과 같이 3차원 입력 데이터에 im2col 을 적용하면 2차원 행렬로 바뀐다. 

정확히는 배치 안의 데이터 수까지 포함한 4차원 데이터를 2차원으로 변환한다.

im2col은 필터링하기 좋게 입력 데이터를 전개한다. 구체적으로는 위 그림과 같이 입력 데이터에서 필터를 적용하는 영역(3차원 블록)을 한줄로 늘어놓는다. 이 전개를 필터를 적용하는 모든 영역에서 수행하는게 im2col이다.

위 그림에서는 보기에 좋게끔 스트라이드를 크게 잡아 필터의 적용 영역이 겹치지 않도록 했지만, 실제 상황에서는 영역이 겹치는 경우가 대부분이다. 

필터 적용 영역이 겹치면 im2col로 전개한 후의 원소 수가 블록의 원소 수보다 많아진다.(이에 메모리를 더 소비하는 단점도 있다)

[Note]

im2col은 'image to column' 즉 '이미지에서 행렬로'라는 뜻이다. 카페와 체이너등의 딥러닝 프레임워크는 im2col이라는 이름의 함수를 만들어 합성곱 계층을 구현할 때 이용하고 있다.

  im2col 함수

def im2col(input_data, filter_h, filter_w, stride=1, pad=0):
    N, C, H, W = input_data.shape
    out_h = (H + 2 * pad - filter_h) // stride + 1
    out_w = (W + 2 * pad - filter_w) // stride + 1

    img = np.pad(input_data, [(0, 0), (0, 0), (pad, pad), (pad, pad)], 'constant')
    col = np.zeros((N, C, filter_h, filter_w, out_h, out_w))

    for y in range(filter_h):
        y_max = y + stride * out_h
        for x in range(filter_w):
            x_max = x + stride * out_w
            col[:, :, y, x, :, :] = img[:, :, y:y_max:stride, x:x_max:stride]

    col = col.transpose(0, 4, 5, 1, 2, 3).reshape(N * out_h * out_w, -1)
    return col

x1=np.random.rand(1,3,7,7) #데이터의 수,채널 수, 높이, 너비
col1=im2col(x1,5,5,stride=1,pad=0)
print(col1.shape) 

(9, 75)

위 예는 batchsize=1(data=1), channel=3, height*width=7*7 

x2=np.random.rand(10,3,7,7)
col2=im2col(x2,5,5,stride=1,pad=0)
print(col2.shape)

(90, 75)

위 예는 batchsize=10(data=10),channel=3,height*width=7*7

위 두 예 모두 2번째 차원의 원소는 75개이다. 이 값은 필터의 원소 수와 같다(channel=3, 5*5 data).

또한, batchsize=1일 때는 im2col의 결과의 크기가 (9,75)이고, 10일 때는 그 10배인 (90,75) 크기의 데이터가 저장된다.

다음은 Convolution class를 구현해보자.

class Convolution:
    def __init__(self,W,b,stride=1,pad=0):
        self.W=W
        self.b=b
        self.stride=stride
        self.pad=pad
    def forward(self,x):
        FN,C,FH,FW=self.W.shape
        N,C,H,W=x.shape
        out_h=int(1+(H+2*self.pad-FH)/self.stride)
        out.w=int(1+(W+2*self.pad-FW)/self.stride)
        
        col=im2col(x,FH,FW,self.stride,self.pad)
        col_W=self.W.reshape(FN,-1).T #필터 전개
        out=np.dot(col,col_W)+self.b
        
        out=out.reshape(N,out_h,out_w,-1).transpose(0,3,1,2)
        
        return out

합성곱 계층은 필터(가중치), 편향, 스트라이드, 패딩을 인수로 받아 초기화한다.

필터는 (FN,C,FH,FW)의 4차원 형상이다. 여기서 FN은 필터 개수, C는 채널, FH는 필터 높이, FW는 필터 너비이다.

col=im2col(x,FH,FW,self.stride,self.pad)
col_W=self.W.reshape(FN,-1).T #필터 전개
out=np.dot(col,col_W)+self.b

위 코드 3줄이 가장 중요하다. 위 코드는 input_data를 im2col로 전개하고 필터도 reshape하여 2차원 배열로 전개한다. 그 후 내적을 진행한다.

forward 구현의 마지막에는 넘파이의 transpose 함수를 사용하는데, 이는 다차원 배열의 축 순서를 바꿔주는 함수이다.

풀링 계층 구현하기

풀링 계층 구현도 함성곱 계층과 마찬가지로 im2col을 사용해 입력 데이터를 전개한다. 단, 풀링의 경우엔 채널 쪽이 독립적이라는 점이 합성곱 계층 때와 다르다. 즉, 풀링 적용 영역을 채널마다 독립적으로 전개한다.

우선 이렇게 전개한 후, 전개한 행렬에서 행별 최댓값을 구하고 적절한 형상으로 성형하면된다.

풀링계층을 코딩으로 구현해보자.

class Pooling:
    def __init__(self,pool_h,pool_w,stride=1,pad=0):
        self.pool_h=pool_h
        self.pool_w=pool_w
        self.stride=stride
        self.pad=pad
        
    def forward(self,x):
        N,C,H,W=x.shape
        out_h=int(1+(H-self.pool_h)/self.stride)
        out_w=int(1+(W-self.pool_w)/self.stride)
        
        #전개(1)
        col=im2col(x,self.pool_h,self.pool_w,self.stride,self.pad)
        col=col.reshape(-1,self.pool*self.pool_w)
        
        #최댓값(2)
        out=np.max(col,axis=1)
        
        #성형(3)
        out=out.reshape(N,out_h,out_w,C).transpose(0,3,1,2)
        return out

[Note]

최댓값 계산에는 넘파이의 np.max 메서드를 사용할 수 있다. np.max는 인수로 축(axis)을 지정할 수 있는데, 이 인수로 지정한 축마다 최댓값을 구할 수 있다. 가령 np.max(x,axis=1)과 같이 쓰면 입력 x의 1번째 축마다 최댓값을 구한다.

CNN 구현하기

합성곱 계층과 풀링 계층을 구현했으니, 조합하여 손글자 인식 CNN을 조립해보자.

초기화 때 받는 인수

-input_dim :입력 데이터(채널 수, 높이,너비)의 차원

-conv_param: 함성곱 계층의 하이퍼파라미터(딕셔너리). 딕셔너리 키는 다음과 같다.

   filter_num: 필터의 수

   filter_size: 필터 크기

   stride: 스트라이드

   pad: 패딩

   hidden_size: 은닉층(fully-connected)의 뉴런 수

   output_size: 출력층(fully_connected)의 뉴런 수

   weight_init_std: 초기화 때의 가중치 표준편차

여기서 CNN 계층의 하이퍼파라미터는 딕셔너리 형태로 주어진다(conv_param).

class SimpleConvNet:
    def __init__(self,input_dim=(1,28,28),
                conv_param={'filter_num':30,'filter_size':5,'pad':0,'stride':1},
                hidden_size=100,output_size=10,weight_init_std=0.01):
        filter_num=conv_param['filter_num']
        filter_size=conv_param['filter_size']
        filter_pad=conv_param['pad']
        filter_stride=conv_param['stride']
        input_size=input_dim[1]
        conv_output_size=(input_size-filter_size+2*filter_pad)/filter_stride+1
        pool_output_size=int(filter_num*(conv_output_size/2)*(conv_output_size/2))
        
        
        self.params={}
        self.params['W1']=weight_init_std*np.random.randn(filter_num,input_dim[0],filter_size,filter_size)
        self.params['b1']=np.zeros(filter_num)
        self.params['W2']=weight_init_std*np.random.randn(pool_output_size,hidden_size)
        self.params['b2']=np.zeros(hidden_size)
        self.parmas['W3']=weight_init_std*np.random.randn(hidden_size,output_size)
        self.params['b3']=np.zeros(output_size)
        
        self.layers=OrderedDict()
        self.layers['Conv1']=Convolution(self.params['W1'],self.params['b1'],conv_param['stride'],conv_param['pad'])
        self.layers['Relu1']=Relu()
        self.layers['Pool1']=Pooling(pool_h=2,pool_w=2,stride=2)
        self.layers['Affine1']=Affine(self.params['W2'],self.params['b2'])
        
        self.layers['Relu2']=Relu()
        self.layers['Affine2']=Affine(self.params['W3'],self.params['b3'])
        
        self.last_layer=SoftmaxWithLoss()
    def predict(self,x):
        for layer in self.layers.values():
            x=layer.forward(x)
        return x
    
    def loss(self,x,t):
        y=self.predict(x)
        return self.last_layer.forward(y,t)
    
    def gradient(self,x,t):
        #순전파
        self.loss(x,t)
        
        #역전파
        dout=1
        dout=self.last_layer.backward(dout)
        
        layers=list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout=layer.backward(dout)
        
        #결과 저장
        grads={}
        grads['W1']=self.layers['Conv1'].dW
        grads['b1']=self.layers['Conv1'].db
        grads['W2']=self.layers['Affine1'].dW
        grads['b2']=self.layers['Affine1'].db
        grads['W3']=self.layers['Affine2'].dW
        grads['b3']=self.layers['Affine2'].db
        
        return grads
    
    
    

이상으로 DeepLearning from Scratch 밑바닥부터 시작하는 딥러닝1을 전부 공부하며 리뷰했다. 다음은 

딥러닝 2를 리뷰하겠다.

CNN(Convolutional neural network)은 이미지 인식과 음성 인식 등 다양한 곳에서 사용된다.

특히, 이미지 인식 분야에서 딥러닝을 활용한 기법은 거의 CNN을 기초로 한다.

전체 구조

CNN도 지금까지 본 신경망과 같이 레고 블록처럼 계층을 조합하여 만들 수 있다. 다만, 합성곱 계층(Convolutional layer)과 풀링 계층(pooling layer)이 등장한다.

복기하자.

완전연결(fully-connected): 인접하는 계층의 모든 뉴런과 결합되어 있는 신경망.

위 계층을 Affine 계층이라는 이름으로 구현했다.

위 그림과 같이 완전연결 신경망은 Affine 계층 뒤에 활성화 함수를 갖는 ReLU 계층(or Sigmoid 계층)이 이어진다.

이 그림에서는 Affine-ReLU 조합이 4개가 쌓였고, 마지막 5번째 층은 Affine 계층에 이어 Softmax 계층에서 최종 결과(확률)를 출력한다.

위 그림은 새로운 '합성곱 계층'과 '풀링 계층'이 추가된다. 

CNN의 계층은 'Conv-ReLU-(Pooling)'흐름으로 연결된다.(Pooling 계층은 필요에 따라 생략하기도 한다)

여기서 주목할 점은 출력에 가까운 층에서는 지금까지의 완전연결 신경망의 'Affine-ReLU'구성을 사용할 수 있다는 것이다. 또한, 마지막 출력 계층에서는 'Affine-Softmax' 조합을 그대로 사용한다.

이상이 일반적인 CNN 구성이다.

합성곱 계층

CNN에서는 패딩(padding), 스트라이드(stride) 등 CNN 고유의 용어가 등장한다. 또한, 각 계층 사이에는 3차원 데이터같이 입체적인 데이터가 흐른다는 점에서 fully-connected와 다르다. 

완전연결 계층의 문제점

간단하게 말하면 fully-connected 계층은 '데이터의 형상이 무시'된다는 점이다.

예를 들어 데이터가 이미지인 경우를 생각해보자. 이미지는 통상 세로 채널(색상)으로 구성된 3차원 데이터이다.

그러나 완전연결 계층에 입력할 때는 3차원 데이터를 평평한 1차원데이터로 평탄화해줘야 한다. 

이전까지의 MNIST 데이터셋을 사용한 사례에서는 형상이 (1,28,28)인 이미지(1채널, 세로 28픽셀, 가로 28픽셀)를 1줄로 세운 784개의 데이터를 첫 Affine 계층에 입력했다.

이미지는 3차원 형상이며, 이 형상에는 공간적 정보가 담겨있다. 예를 들어 공간적으로 가까운 픽셀은 값이 비슷하거나, RGB의 각 채널은 서로 밀접하게 관련되어 있거나, 거리가 먼 픽셀끼리는 별 연관이 없는 등, 3차원 속에서 의미를 갖는 본질적인 패턴이 숨어 있을 것이다. 

이에 완전연결 계층은 형상(공간적 정보)은 무시하고 모든 입력 데이터를 동등한 뉴런(같은 차원의 뉴런)으로 취급하여 형상에 담긴 정보를 살릴 수 없다.

하지만 합성곱 계층은 형상을 유지한다. 이미지도 3차원 데이터로 입력받으며, 마찬가지로 다음 계층에도 3차원 데이터로 전달한다. 

그래서 CNN에서는 이미지처럼 형상을 가진 데이터를 제대로 이해할 (가능성이 있는) 것이다.

CNN에서는 합성곡 계층의 입출력 데이터를 특징 맵(feature map)이라고 한다. 합성곱 계층의 입력 데이터를 입력 특징 맵(input feature map), 출력 데이터를 출력 특징맵(output feature map)이라고 한다.

합성곱 연산

합성곱 계층에서의 합성곱 연산을 처리한다. 합성곱 연산은 이미치 처리에서는 필터연산에 해당한다.

위 그림과 같이 합성곱 연산은 입력 데이터에 필터를 적용한다. 입력 데이터는 세로*가로 방향의 형상을 가졌고, 필터 역시 세로*가로 방향의 차원을 갖는다. 데이터와 필터의 형상을 (height,width)로 표기하며, 이 예에서는 입력은 (4,4),필터는 (3,3), 출력은 (2,2)가 된다. 문헌에 따라 필터를 커널이라고 칭하기도 한다.

합성곱 연산은 필터의 윈도우를 일정 간격으로 이동해가며 입력 데이터에 적용한다. 

여기서 말하는 윈도우는 위 그림에서 회색 3*3 부분을 가리킨다. 그림과 같이 입력 필토에서 대응하는 원소끼리 곱한 후 그 총합을 구한다.(이 계산을 단일 곱셈-누산 fused multiply-add,FMA라 한다).

그 후 결과를 출력의 해당 장소에 저장한다. 이 과정을 모든 장소에서 수행하면 합성곱 연산의 출력이 완성된다.

*fully-connected neural network에는 가중치 매개변수와 편향이 존재한다. 

*CNN에서는 필터의 매개변수가 그동안의 '가중치'에 해당한다. 또한 편향도 존재한다.

패딩(Padding)

패딩이란 합성곱 연산을 수행하기 전에 입력 데이터 주변을 특정 값 으로 채우는 것을 말한다.

합성곱 연산에서는 자주 이용하는 기법이다. 

위 그림과 같이 처음 크기가 (4,4)인 입력 데이터에 패딩이 추가되어 (6,6)이 된다. 이 입력에 (3,3)크기의 필터를 걸면 (4,4) 크기의 출력 데이터가 생성된다. 

위 예는 패딩을 1로 설정했지만, 2로 설정하면 입력 데이터의 크기는 (8,8)이 되고 3으로 설정하면 (10,10)이 된다.

[Note]

패딩은 주로 출력 크기를 조정할 목적으로 사용한다. 예를 들어 (4,4) 입력 데이터에 (3,3)필터를 적용하면 출력은 (2,2)가되어 입력보다 2만큼 줄어든다. 이는 합성곱 연산을 몇 번이나 되플이하는 심층 신경망에서는 문제가 될 수 있다. 합성곱 연산을 거칠 때마다 크기가 작아지면 어느 시점에서는 출력 크기가 1이 되버린다. 즉, 더 이상 합성곱 연산을 적용할 수 없다는 뜻이다. 이를 막기 위해 패딩을 사용한다. 앞의 예에서는 패딩의 폭을 1로 설정하니 (4,4) 입력에 대한 출력이 같은 크기인 (4,4)로 유지되었다. 

스트라이드(Stride)

스트라이드란 필터를 적용하는 위치의 간격을 말한다. 지금까지 본 예는 스트라이드가 1이었지만, 스트라이드를 2로 하면 필터를 적용하는 윈도우가 두 칸씩 이동한다.

스트라이드를 2로 하면 출력은 (3,3)이 된다. 이처럼 스트라이드를 키우면 출력 크기는 작아진다. 

이와 반대로 패딩을 크게 하면 출력 크기는 커졌다. 수식으로 확인해보자.

입력 크기를 (H,W), 필터 크기를(FH,FW), 출력 크기를 (OH,OW), 패딩을 P, 스트라이드를 S라 하면, 출력크기는 다음과 같다.

위 예들처럼 단순히 값을 대입하기만 하면 출력 크기를 구할 수 있다.

단, OH와 OW가 정수로 나눠떨어지는 값이어야 한다는 점에 주의하자.

출력 크기가 정수가 아니면 오류를 내는 등의 대응을 해줘야 한다. 덧붙여, 딥러닝 프레임워크 중에는 값이 딱 나눠떨어지지 않을 때는 가장 가까운 정수로 반올림하는 등, 특별히 에러를 내지 않고 진행하도록 구현하는 경우도 있다.

3차원 데이터의 합성곱 연산

지금까지 2차원 형상을 다루는 합성곱 연산을 보았다. 그러나 이미지는 3차원 데이터라고 앞서 언급했다. 3차원 합성곱 연산에 대해 알아보자.

위 두 그림을 보면 길이 방향(채널 방향)으로 특징 맵이 늘어났다. 채널 쪽으로 특징 맵이 여러 개 있다면 입력 데이터와 필터의 합성곱 연산을 채널마다 수행하고, 그 결과를 더해서 하나의 출력을 얻는다.

주의할 점은 입력 데이터의 채널 수와 필터의 채널 수가 같아야 한다.

한편, 필터 자체의 크기는 원하는 값으로 설정할 수 있다.(단, 모든 채널의 필터가 같은 크기여야 한다).

위 예에서는 필터의 크기가 (3,3)이지만, 원한다면 (2,2)나 (1,1) 혹은 (5,5)등으로 설정해도 된다.

블록으로 생각하기

3차원의 합성곱 연산은 데이터와 필터를 직육면체 블록이라고 생각하면 쉽다.

예를 들어 채널 수 C,높이 H, 너비 W인 데이터의 형상은 (C,H,W)로 쓴다. 필터도 같은 순서로 쓴다. 

채널 수 C, 필터 높이(FH filter height), 필터 너비(FW filter width)로 쓴다.

합성곱 연산의 출력으로 다수의 채널을 내보내려면 어떻게 해야 할까? 답은 필터(가중치)를 다수 사용하는 것이다.

위 그림과 같이 필터를 FN개 적용하면 출력 맵도 FN개가 생성된다. 그 FN개의 맵을 모으면 형상이 (FN,OH,OW)인 블록이 완성된다. 

이 완성된 블록을 다음 계층으로 넘기겠다는 것이 CNN의 처리 흐름이다.

합성곱 연산에서는 필터의 수도 고려해야 한다. 그런 이유로 필터의 가중치 데이터는 4차원 데이터이다. 예를 들어 채널 수 3, 크기 5*5 인 필터가 20개 있다면 (20,3,5,5)로 쓴다.

합성곱 연산에도 (완전연결 계층과 마찬가지로) 편향이 쓰인다. 

위 그림과 같이 편향은 채널 하나에 값 하나씩으로 구성된다. 위 예에서 편향의 형상은 (FN,1,1)이고, 필터의 출력 결과의 형상은 (FN,OH,OW)이다. 이들 두 블록을 더하면 편향의 각 값이 필터의 출력인 (FN,OH,OW) 블록의 대응 채널의 원소 모두에 더해진다. 

배치 처리

신경망 처리에서는 입력 데이터를 한 덩어리로 묶어 배치로 처리했다. 완전연결 신경망을 구현하면서는 이 방식을 지원하여 처리 효율을 높이고, 미니배치 방식의 학습도 지원하도록 했다. 합성곱 연산도 마찬가지로 배치 처리를 지원하고자 한다. 각 계층을 흐르는 데이터의 차원을 하나 늘려 4차원 데이터로 저장한다. 구체적으로는 데이터를 (데이터 수, 채널 수, 높이, 너비) 순으로 저장한다. 

위 그림을 보면 각 데이터의 선두에 배치용 차원을 추가했다. 이처럼 데이터는 4차원 형상을 가진 채 각 계층을 타고 흐른다. 주의할 점으로는 신경망에 4차원 데이터가 하나 흐를 때마다 데이터 N개에 대한 합성곱 연산이 이뤄진다는 것이다. 즉, N회 분의 처리를 한번에 수행하는 것이다.

풀링(Pooling) 계층

풀링은 세로 가로 방향의 공간을 줄이는 연산이다. 

위 그림은 2*2 최대 풀링(max pooling)을 스트라이드 2로 처리하는 순서이다. 최대 풀링은 최댓값을 구하는 연산으로, '2*2'는 대상 영역의 크기를 뜻한다. 즉 2*2 최대 풀링은 그림과 같이 2*2 크기의 영역에서 가장 큰 원소 하나를 꺼낸다. 

그 후 윈도우가 2칸 간격으로 이동한다. 

참고로 풀링의 윈도우 크기와 스트라이드는 같은 값으로 설정하는 것이 보통이다.

[Note]

최대 풀링(max pooling): 대상 영역(윈도우 영역) 에서 최댓값을 취하는 연산

평균 풀링(average poling): 대상 영역(윈도우 영역)에서의 평균을 계산한다. 

*이미지 인식 분야에서는 주로 최대 풀링을 사용한다. 

풀링 계층의 특징

학습해야 할 매개변수가 없다.

풀링은 대상 영역에서 최댓값이나 평균을 취하는 명확한 처리이므로 특별히 학습할 것이 없다.

채널 수가 변하지 않는다.

풀링 연산은 입력 데이터의 채널 수 그대로 출력 데이터로 내보낸다. 독립적으로 계산하기 때문.

입력의 변화에 영향을 적게 받는다(강건하다)

입력 데이터가 조금 변해도 풀링의 결과는 잘 변하지 않는다. 

에러가 나오는 원인

get_config라는 함수가 없기때문.

callback 함수를 사용해 모델을 저장하려하는데 위 에러 발생

callback 함수를 사용하지 않고 model.fit을 하는 경우에는 위 에러가 발생하지 않는다.

해결 방법

model class 내에 get_config라는 함수를 만들어 주면 된다.

def get_config(self):
    config=super().get_config().copy()
    return config

참고URL:stackoverflow.com/questions/58678836/notimplementederror-layers-with-arguments-in-init-must-override-get-conf

챗봇을 만들기 위해서는 우선 앞선 포스팅인 트랜스포머에 대해서 이해하고 다음을 알아보자.

https://undeadkwandoll.tistory.com/26

undeadkwandoll.tistory.com/27

데이터 로드

시작하기전 필요한 라이브러리를 불러오자.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import re
import urllib.request
import time
import tensorflow_datasets as tfds
import tensorflow as tf

챗봇 데이터를 로드하여 상위 5개 샘플 출력해보자.

urllib.request.urlretrieve("https://raw.githubusercontent.com/songys/Chatbot_data/master/ChatbotData%20.csv", filename="ChatBotData.csv")
train_data = pd.read_csv('ChatBotData.csv')
train_data.head()

위 데이터를 보면 Q(question), A(answer) 의 쌍으로 이루어진 데이터이다.

#총 샘플 개수 확인
print('챗봇 샘플의 개수 :',len(train_data))

챗봇 샘플의 개수 : 11823

총 샘플 갯수는 11823개이며, 불필요한 NULL값이 있는지 확인해보자.

print(train_data.isnull().sum())

Null값은 별도로 존재하지 않는다. 기본적으로 사용하는 토큰화를 위한 형태소 분석툴을 사용하지 않고, 다른 방법인 학습 기반의 토크나이저를 사용할 것이다. 그러므로, row data에서 구두점을 미리 처리해야한다. 

구두점들은 단순히 제거해버릴수 있지만, 구두점 앞에 띄어쓰기를 추가하여 다른 문자들과 구분해보자.

questions=[]
for sentence in train_data['Q']:
    #구두점에 대해서 띄어쓰기
    #ex) 12시 땡! ->12시 땡 !
    sentence=re.sub(r"([?.!,])", r" \1",sentence)
    sentence=sentence.strip()
    questions.append(sentence)
answers=[]
for sentence in train_data['A']:
    #구두점에 대해서 띄어쓰기
    #ex) 12시 땡! ->12시 땡 !
    sentence=re.sub(r"([?.!,])",r" \1",sentence)
    sentence=sentence.strip()
    answers.append(sentence)

이후 잘 처리가 되었는지 확인해보자.

print(questions[:5])
print(answers[:5])



['12시 땡 !', '1지망 학교 떨어졌어', '3박4일 놀러가고 싶다', '3박4일 정도 놀러가고 싶다', 'PPL 심하네']
['하루가 또 가네요 .', '위로해 드립니다 .', '여행은 언제나 좋죠 .', '여행은 언제나 좋죠 .', '눈살이 찌푸려지죠 .']

다음과 같이 잘 처리되었다.

단어 집합 생성

서브워드텍스트인코더를 사용해 자주 사용되는 서브워드 단위로 토큰을 분리하는 토크나이저로 학습 데이터로부터 학습하여 서브워드로 구성된 단어 집합을 생성해보자.

#서브워드텍스트인코더를 사용하여 질문, 답변 데이터로부터 단어 집합(Vocabulary) 생성
tokenizer=tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(questions+answers,target_vocab_size=2**13)

seq2seq에서의 인코더-디코더 모델 계열에는 디코더의 입력으로 사용할 시작을 의미하는 시작 토큰 SOS와 종료 토큰 EOS 또한 존재한다. 해당 토큰들도 단어 집합에 포함시킬 필요가 있으므로 이 두 토큰에 정수를 부여하자.

#시작 토큰과 종료 토큰에 대한 정수 부여.
START_TOKEN,END_TOKEN=[tokenizer.vocab_size],[tokenizer.vocab_size+1]

#시작 토큰과 종료 토큰을 고려햐여 단어 집합의 크기를 +2
VOCAB_SIZE=tokenizer.vocab_size+2

print('시작 토큰 번호: ',START_TOKEN)
print('종료 토큰 번호: ',END_TOKEN)
print('단어 집합의 크기: ',VOCAB_SIZE)


시작 토큰 번호:  [8170]
종료 토큰 번호:  [8171]
단어 집합의 크기:  8172

padding에 사용될 0번 토큰부터 마지막 토큰인 8171번 토큰까지의 개수를 카운트하면 단어 집합의 크기는 8172개이다.

정수 인코딩과 패딩

단어 집합 생성 후, 서브워드텍스트인코더의 토크나이저로 정수 인코딩을 진행할 수 있다. 이는 토크나이저의 .encode()를 사용하여 가능하다. 랜덤샘플 20번 질문 샘플, 즉 ,questions[20]을 갖고 인코딩 해보자.

#서브워드텍스트인코더 토크나이저의 .encode()를 사용하여 텍스트 시퀀스를 정수 시퀀스로 변환.
print('임의의 질문 샘플을 정수 인코딩 : {}'.format(tokenizer.encode(questions[20])))

임의의 질문 샘플을 정수 인코딩 : [5759, 607, 3502, 138, 681, 3740, 846]

임의의 질문 문장이 정수 시퀀스로 변환되었다. 반대로 정수 인코딩 된 결과는 다시 decode()를 사용해 기존의 텍스트 시퀀스로 복원할 수 있다. 

#서브워드텍스트인코더 토크나이저의 .encode()와 .decode() 테스트해보기
#임의의 입력 문장을 sample_string에 저장
sample_string=questions[20]

#encode() : 텍스트 시퀀스 -->정수 시퀀스
tokenized_string=tokenizer.encode(sample_string)
print('정수 인코딩 후의 문장 {}'.format(tokenized_string))

#decode(): 정수 시퀀스-->텍스트 시퀀스
original_string=tokenizer.decode(tokenized_string)
print('기존 문장: {}'.format(original_string))


정수 인코딩 후의 문장 [5759, 607, 3502, 138, 681, 3740, 846]
기존 문장: 가스비 비싼데 감기 걸리겠어

정수 인코딩 된 문장을 .decode()를 하면 자동으로 서브워드들까지 다시 붙여서 기존 단어로 복원해준다. 위 결과를 보면 정수가 7개인데 기존 문장의 띄어쓰기 단위인 어절은 4개밖에 존재하지 않는다. 이는 결국 '가스비','비싼데'라는 한 어절이 정수 인코딩 후에는 두 개 이상의 정수일 수 있다는 것이다.

확인해보자.

#각 정수는 각 단어와 어떻게 mapping되는지 병렬로 출력
#서브워드텍스트인코더는 의미있는 단위의 서브워드로 토크나이징한다. 띄어쓰기 단위 x형태소 분석 단위 x
for ts in tokenized_string:
    print('{}----->{}'.format(ts,tokenizer.decode([ts])))
    
    
5759----->가스
607----->비 
3502----->비싼
138----->데 
681----->감기 
3740----->걸리
846----->겠어

샘플1개를 갖고 인코딩 디코딩을 해보았다. 이제 전체 데이터에 대해 정수 인코딩과 패딩을 하자. 

#최대 길이를 40으로 정의
MAX_LENGTH=40

#토큰화/정수 인코딩/ 시작 토큰과 종료 토큰 추가/ 패딩
def tokenize_and_filter(inputs,outputs):
    tokenized_inputs,tokenized_outputs=[],[]
    
    for (sentence1,sentence2) in zip(inputs,outputs):
        #encode(토큰화 +정수 인코딩), 시작 토큰과 종료 토큰 추가
        sentence1=START_TOKEN+tokenizer.encode(sentence1)+END_TOKEN
        sentence2=START_TOKEN+tokenizer.encode(sentence2)+END_TOKEN
        
        tokenized_inputs.append(sentence1)
        tokenized_outputs.append(sentence2)
        
    #패딩
    tokenized_inputs=tf.keras.preprocessing.sequence.pad_sequences(tokenized_inputs,maxlen=MAX_LENGTH,padding='post')
    tokenized_outputs=tf.keras.preprocessing.sequence.pad_sequences(tokenized_outputs,maxlen=MAX_LENGTH,padding='post')

    return tokenized_inputs,tokenized_outputs

questions,answers=tokenize_and_filter(questions,answers)

데이터의 크기를 확인해보자.

print('질문 데이터의 크기(shape): ',questions.shape)
print('답변 데이터의 크기(shape): ',answers.shape)

질문 데이터의 크기(shape):  (11823, 40)
답변 데이터의 크기(shape):  (11823, 40)

임의로 3번 샘플을 출력해보자.

print(questions[3])
print(answers[3])

길이 40을 맞추기 위해 뒤에 0이 임의로 패딩되어있는 것을 확인할 수 있다.

인코더와 디코더의 입력, 레이블 만들기.

데이터를 배치 단위로 불러오기 위해 tf.data.Dataset을 사용한다.

#텐서플로우 dataset을 이용하여 셔플(shuffle)을 수행하되, 배치 크기로 데이터를 묶는다.
#또한 이 과정에서 교사 강요(teacher forcing)을 사용하기 위해서 디코더의 입력과 실제 값 시퀀스를 구성한다.
BATCH_SIZE=64
BUFFER_SIZE=20000

#디코더의 실제값 시퀀스에서는 시작 토큰을 제거해야 한다.
dataset=tf.data.Dataset.from_tensor_slices((
    {
        'inputs':questions,
        'dec_inputs':answers[:,:-1] #디코더의 입력. 마지막 패딩 토큰이 제거된다.
    },
    {
      'outputs':answers[:,1:]  
    },
))

dataset=dataset.cache()
dataset=dataset.shuffle(BUFFER_SIZE)
dataset=dataset.batch(BATCH_SIZE)
dataset=dataset.prefetch(tf.data.experimental.AUTOTUNE)

#임의의 샘플에 대해서 [:,:-1] 과 [:,1:]이 어떤 의미를 가지는지 테스트해본다.
#기존 샘플
print(answers[0]) 
#마지막 패딩 토큰 제거하면서 길이가 39가 된다
print(answers[:1][:,:-1]) 
#맨 처음 토큰이 제거된다. 다시 말해 시작 토큰이 제거된다. 길이는 역시 39가 된다
print(answers[:1][:,1:]) 

트랜스포머 만들기

하이퍼파라미터를 조정하여 실제 논문의 트랜스포머보다는 작은 모델을 만든다.

주요 하이퍼파라미터는 다음과 같다.

tf.keras.backend.clear_session()

#Hyper-parameters
D_MODEL=256
NUM_LAYERS=2
NUM_HEADS=8
DFF=512
DROPOUT=0.1

model=transformer(
    vocab_size=VOCAB_SIZE,
    num_layers=NUM_LAYERS,
    dff=DFF,
    d_model=D_MODEL,
    num_heads=NUM_HEADS,
    dropout=DROPOUT)

learning rate, optimizer을 정의하고 compile 해보자

learning_rate=CustomSchedule(D_MODEL)
optimizer=tf.keras.optimizers.Adam(learning_rate,beta_1=0.9,beta_2=0.98,epsilon=1e-9)

def accuracy(y_true,y_pred):
    #레이블의 크기는 (batch_size, MAX_LENGTH-1)
    y_true=tf.reshape(y_true,shape=(-1,MAX_LENGTH-1))
    return tf.keras.metrics.sparse_categorical_accuracy(y_true,y_pred)

model.compile(optimizer=optimizer,loss=loss_function,metrics=[accuracy])

EPOCHS=50
model.fit(dataset,epochs=EPOCHS)

Epoch 1/50
185/185 [==============================] - 272s 1s/step - loss: 1.4499 - accuracy: 0.0304
Epoch 2/50
185/185 [==============================] - 256s 1s/step - loss: 1.1818 - accuracy: 0.0495
Epoch 3/50
185/185 [==============================] - 273s 1s/step - loss: 1.0029 - accuracy: 0.0507
Epoch 4/50
185/185 [==============================] - 276s 1s/step - loss: 0.9276 - accuracy: 0.0547
Epoch 5/50
185/185 [==============================] - 263s 1s/step - loss: 0.8703 - accuracy: 0.0575
										.
                                        .
                                        .
Epoch 45/50
185/185 [==============================] - 204s 1s/step - loss: 0.0068 - accuracy: 0.1734
Epoch 46/50
185/185 [==============================] - 206s 1s/step - loss: 0.0068 - accuracy: 0.1735
Epoch 47/50
185/185 [==============================] - 206s 1s/step - loss: 0.0062 - accuracy: 0.1736
Epoch 48/50
185/185 [==============================] - 203s 1s/step - loss: 0.0063 - accuracy: 0.1736
Epoch 49/50
185/185 [==============================] - 204s 1s/step - loss: 0.0058 - accuracy: 0.1737
Epoch 50/50
185/185 [==============================] - 204s 1s/step - loss: 0.0058 - accuracy: 0.1737
<tensorflow.python.keras.callbacks.History at 0x2076df63ca0>

챗봇 평가

def evaluate(sentence):
    sentence = preprocess_sentence(sentence)

    sentence = tf.expand_dims(
      START_TOKEN + tokenizer.encode(sentence) + END_TOKEN, axis=0)

    output = tf.expand_dims(START_TOKEN, 0)

  # 디코더의 예측 시작
    for i in range(MAX_LENGTH):
        predictions = model(inputs=[sentence, output], training=False)

    # 현재(마지막) 시점의 예측 단어를 받아온다.
        predictions = predictions[:, -1:, :]
        predicted_id = tf.cast(tf.argmax(predictions, axis=-1), tf.int32)

    # 만약 마지막 시점의 예측 단어가 종료 토큰이라면 예측을 중단
        if tf.equal(predicted_id, END_TOKEN[0]):
            break

    # 마지막 시점의 예측 단어를 출력에 연결한다.
    # 이는 for문을 통해서 디코더의 입력으로 사용될 예정이다.
        output = tf.concat([output, predicted_id], axis=-1)

    return tf.squeeze(output, axis=0)

def predict(sentence):
    prediction = evaluate(sentence)

    predicted_sentence = tokenizer.decode(
      [i for i in prediction if i < tokenizer.vocab_size])

    print('Input: {}'.format(sentence))
    print('Output: {}'.format(predicted_sentence))

    return predicted_sentence 

def preprocess_sentence(sentence):
    sentence = re.sub(r"([?.!,])", r" \1 ", sentence)
    sentence = sentence.strip()
    return sentence

output = predict("영화 볼래?")
Input: 영화 볼래?
Output: 최신 영화가 좋을 것 같아요.

output=predict("머신러닝이란..")
Input: 머신러닝이란..
Output: 축하할 일이죠.

output=predict("너 불굴의관돌이 알아?")
Input: 너 불굴의관돌이 알아?
Output: 저도 쉬고 놀고 하고 싶어요.

output=predict("힘들구나")
Input: 힘들구나
Output: 건강에 유의하세요.

대략 4개정도 확인해보았지만 어느정도는 대답을 해주는 것을 볼 수 있다. 위 과정은 간단하게 만든 것이기에 이정도이지만, 실제 데이터를 더 많이 늘려서 시행해본다면 더 좋은 결과를 나을 수 있다고 생각해본다.

[출처]https://wikidocs.net/89786

Batch Normalization

앞전 포스팅에서 각 층의 활성화 값 분포를 관찰하며, 가중치의 초깃값을 적절히 설정하면 각 층의 활성화값 분포가 적당히 퍼지며, 학습이 원만하게 수행됨을 배웠다.

그렇다면,

각 층이 활성화를 적당히 퍼뜨리도록 '강제' 해보면 어떨까?

Batch Normalization Algorithm

배치 정규화가 주목받는 이유는 3가지가 있다.

1) 학습을 빨리 진행할 수 있다(학습 속도 개선)

2) 초깃값에 크게 의존하지 않는다(골치 아픈 초깃값 선택 장애 해소)

3) 오버피팅을 억제한다(드롭아웃 등의 필요성 감소)

배치 정규화는 그 이름과 같이 학습 시 미니배치를 단위로 정규화한다. 데이터 분포가 평균이 0, 분산이 1이 되도록 정규화 하는 것이다.

수식은 다음과 같다.

미니배치 B={x1,x2,x....,xm}이라는 M개의 입력 데이터의 집합에 대해 평균 수식 1과 분산 수식 2를 구한다.

이 처리를 활성화 함수의 앞(혹은 뒤)에 삽입함으로써 데이터 분포가 덜 치우치게 할 수 있다.

또, 배치 정규화 계층마다 이 정규화된 데이터에 고유한 확대와 이동변환을 수행한다.

수식은 다음과 같다.

이 식에서 람다가 확대(scale)를 베타가 이동(shift)를 담당한다. 두 값은 처음에는 각 1,0부터 시작하고 학습하면서 적합한 값으로 조정해간다.

Batch Normalization 효과

MNIST데이터셋을 이용해 배치정규화 진도율을 확인해보았다. 거의 모든 경우에서 배치 정규화를 사용할 때의 학습 진도가 빠른 것을 나타난다. 실제로 이용하지 않는 경우, 초깃값이 잘 분포되어 있지 않으면 학습이 전혀 진행되지 않는 모습도 확인된다.

바른 학습을 위해

기계학습에서는 오버피팅이 문제가 되는 일이 많다. 

오버피팅이란 신경망이 훈련데이터에만 지나치게 적응되어 그 외의 데이터에는 제대로 대응하지 못하는 상태를 말한다.

우리의 목표는 기계학습의 범용 성능이다. 훈련 데이터에는 포함되지 않는, 아직 보지 못한 데이터가 주어져도 바르게 식별해내는 모델이 바람직하다. 

오버피팅

오버피팅이 일어날 가장 주된 경우는 2가지가 있다.

1)매개변수가 많고 표현력이 높은 모델

2)훈련 데이터가 적을때

다음 코드는 일부로 오버피팅을 일으킨 코딩이다.

(x_train,t_train),(x_test,t_test)=load_mnist(normalize=True)
#오버피팅을 재현하기 위해 학습 데이터 수를 줄임
x_train=x_train[:300]
t_train=t_train[:300]

network=MultiLayerNet(input_size=784,hidden_size_list=[100,100,100,100,100,100],output_size=10)
#학습률이 0.01인 SGD로 매개변수 갱신
optimizer=SGD(lr=0.01)
max_epochs=201
train_size=x_train.shape[0]
batch_size=100

train_loss_list=[]
train_acc_list=[]
test_acc_list=[]

iter_per_epoch=max(train_size/batch_size,1)
epoch_cnt=0

for i in range(100000000):
    batch_mask=np.random.choice(train_size,batch_size)
    x_batch=x_train[batch_mask]
    t_batch=t_train[batch_mask]
    
    grads=network.gradient(x_batch,t_batch)
    optimizer.update(network.params,grads)
    
    if i%iter_per_epoch==0:
        train_acc=network.accuracy(x_train,t_train)
        test_acc=network.accuracy(x_test,t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        
        epoch_cnt+=1
        if epoch_cnt>=max_epochs:
            break

훈련 데이터를 사용하여 측정환 정확도는 100 에폭을 지나는 무렵부터 거의 100%이다. 

하지만, 시험 데이터에 대해서는 큰 차이를 보인다. 이처럼 정확도가 크게 벌어지는 것은  훈련데이터에만 적응해버린 것이다.

가중치 감소

오버피팅 억제용으로 예로부터 많이 이용해온 방법 중 가중치 감소(weight decay)가 있다.

이는 큰 가중치에 대해서는 그에 상응하는 큰 페널티를 부과하여 오버피팅을 억제하는 방법이다. 원래 오버피팅은 가중치 매개변수의 값이 커서 발생하는 경우가 많기 때문이다. 

이와 비슷한 것이 통계학에서는 회귀분석시 수치적 오류가 나는 것을 피하기위해 표준상관계수분석등을 추가로 하는 이유가 이런 것이다.(?)라고 한번 생각해본다.

신경망 학습의 목적은 손실 함수의 값을 줄이는 것이다. 이때 예를 들어 가중치의 제곱 norm을 손실함수에 더해주는 방법도 있다.

드롭아웃

가중치 감소는 간단하게 구현할 수 있고 어느 정도 지나친 학습을 억제할 수 있다. 그러나 신경망 모델이 복잡해지면 가중치 감소만으로는 대응하기 어려워진다. 이를 흔히 드롭아웃(drop out)이라는 기법을 이용한다.

드롭아웃이란 뉴런을 임의로 삭제하면서 학습하는 방법이다.

훈련 때 은닉층의 뉴런을 무작위로 골라 삭제한다. 삭제된 뉴런은 아래 그림과 같이 신호를 전달하지 않게 된다. 훈련때는 데이터를 흘릴 때마다 삭제할 뉴런을 무작위로 선택하고, 시험 떄는 모든 뉴런에 신호를 전달한다. 

단, 시험 때는 각 뉴런의 출력에 훈련 때 삭제한 비율을 곱하여 출력한다.

코딩을 살펴보자.

class Dropout:
    def __init__(self,dropout_ratio=0.5):
        self.dropout_ratio=dropout_ratio
        self.mask=None
    def forward(self,x,train_flg=True):
        if train_flg:
            self.mask=np.random.rand(*x.shape)>self.dropout_ratio
            return x*self.mask
    def backward(self,dout):
        return dout*self.mask

핵심은 훈련 시에는 순전파 때마다 self.mask에 삭제할 뉴런을 False로 표시한다는 것이다. 

self.mask는 x와 형상이 같은 배열을 무작위로 생성하고, 그 값이 dropout_ratio보다 큰 원소만 True로 설정한다.

역전파 때의 동작은 ReLU와 같다.

즉, 순전파때 신호를 통과시키는 뉴런은 역전파 때도 신호를 그대로 통과시키고, 순전파 때 통과시키지 않은 뉴런은 역전파 때도 신호를 차단한다.

위 그림과 같이 드롭아웃을 적용하니 훈련 데이터와 시험 데이터에 대한 정확도 차이가 줄었음을 볼 수있다.

또한, 훈련 데이터에 대한 정확도가 100%에 도달하지도 않게 되었다.

[Note]

기계학습에서는 앙상블 학습(ensemble learning)을 애용한다.

앙상블 학습은 개별적으로 학습시킨 여러 모델의 출력을 평균내어 추론하는 방식이다.
신경망의 맥락에서 얘기하면, 가령 같은 구조의 네크워크를 5개 준비하여 따로따로 학습시키고, 시험 때는 그 5개의 출력을 평균 내어 답하는 것이다.
앙상블 학습을 수행하면 신경망의 정확도가 몇% 정도 개선된다는 것이 실험적으로 알려져 있다.

앙상블 학습은 드롭아웃과 밀접하다.
드롭아웃이 학습 때 뉴런을 무작위로 삭제하는 행위를 매번 다른 모델을 학습시키는 것으로 해석할 수 있기 때문이다.
그리고 추론 때는 뉴런의 출력에 삭제한 비율(이를테면 0.5 등)을 곱함으로써 앙상블 학습에서 여러 모델의 평균을 내는 것과 같은 효과를 얻는 것이다.

즉, 드롭아웃은 앙상블 학습과 같은 효과를 (대략) 하나의 네트워크로 구현했다고 생각할 수 있다.

적절한 하이퍼파라미터 값 찾기

신경망에는 하이퍼파라미터가 다수 등장한다. 여기서 말하는 하이퍼파라미터는, 예를 들면 각 층의 뉴런 수, 배치 크기, 매개변수 갱신 시의 학습률과 가중치 감소 등이다. 이러한 하이퍼파라미터의 값을 적절히 설정하지 않으면 모델의 성능이 크게 떨어지기도 한다. 하이퍼라라미터의 값은 매우 중요하지만 그 값을 결정하기까지는 일반적으로 많은 시행착오를 겪는다.

검증 데이터

앞으로 하이퍼파라미터를 다양한 값으로 설정하고 검증할 텐데, 여기서 주의할 점은 하이퍼파라미터의 성능을 평가할 때는 시험 데이터를 사용해서는 안된다.

같은 성능 평가인데 안되는 이유가 무엇일까?

대답은 시험 데이터를 사용하여 하이퍼파라미터를 조정하면 하이퍼파라미터 값이 시험 데이터에 오버피팅되기 때문이다. 다시 말해, 하이퍼파라미터 값의 '좋음'을 시험 데이터로 확인하게 되므로 하이퍼파라미터 값이 시험 데이터에만 적합하도록 조정되어 버린다.

그래서 하이퍼파라미터를 조정할 떄는 하이퍼파라미터 전용 확인 데이터가 필요하다. 하이퍼파라미터 조정용 데이터를 일반적으로 검증데이터(validation data)라고 부른다.

[Note]

훈련 데이터는 매개변수(가중치와 편향)의 학습에 이용하고, 검증 데이터는 하이퍼파라미터의 성능을 평가하는 데 이용한다. 

시험 데이터는 범용 성능을 확인하기 위해서 마지막에 (이상적으로는 한번만) 이용한다.

-훈련데이터: 매개변수 학습

-검증데이터: 하이퍼파라미터 성능 평가

-시험데이터: 신경망의 범용 성능 평가

코드로 살펴보자.

(x_train,t_train),(x_test,t_test)=load_mnist()

#훈련 데이터를 뒤섞는다.
x_train,t_train=shuffle_dataset(x_train,t_train)

#20%를 검증 데이터로 분할
validation_rate=0.2
validation_num=int(x_train.shape[0]*validation_rate)

x_val=x_train[:validation_num]
t_val=t_train[:validation_num]
x_train=x_train[validation_num:]
t_train=t_train[validation_num:]

위 코드는 훈련 데이터를 분리하기 전에 입력 데이터와 정답 레이블을 섞는다. 이어서 검증 데이터를 사용하여 하이퍼파라미터를 최적화하는 기법을 살펴보자.

하이퍼파라미터 최적화

하이퍼파라미터를 최적화할 때의 핵심은 하이퍼파라미터의 '최적 값'이 존재하는 범위를 줄여나간다는 것이다. 

범위를 조금씩 줄이려면 우선 대략적인 범위를 설정하고 그 범위에서 무작위로 하이퍼파라미터 값을 골라낸(샘플링) 후, 그 값으로 정확도를 평가한다.

[Note] 

신경망의 하이퍼파라미터 최적화에서는 그리드 서치(grid search)같은 규칙적인 탐색보다는 무작위로 샘플링해 탐색하는 편이 좋은 결과를 낸다고 알려져 있다. 이는 최종 정확도에 미치는 영향력이 하이퍼파라미터마다 다르기 때문이다.

하이퍼파라미터의 범위는 '대략적' 지정이 가장 효과적이다. 실제로도 0.001에서 1000사이와 같이 10의 거듭제곱 단위로 범위를 지정한다. 이를 log scale이라고 부른다.

정리해보면,

1)하이퍼파라미터 값의 범위를 설정한다.

2)설정된 범위에서 하이퍼파라미터의 값을 무작위로 추출한다.

3)2단계에서 샘플링한 하이퍼파라미터 값을 사용하여 학습하고 검증 데이터로 정확도를 평가한다. (단, epoch은 작게 설정)

4)2단계와 3단계를 특정 횟수(log scale)반복하여, 그 정확도의 결과를 보고 하이퍼파라미터의 범위를 좁힌다.

MNIST 예제를 통해 결과를 살펴보면,

학습이 잘 진행될 때의 학습률은 0.001~0.01, 가중치 감소 계수는 10^-8~10^-6정도라는 것을 알 수 있다.

이처럼 잘될 것 같은 값의 범위를 관찰하고 범위를 좁혀가면된다.