1. Time Series ์๊ฐยถ
์๊ณ์ด ์์ธก์ ๊ณผ๊ฑฐ์ ๊ด์ธก๋ ๊ฐ์ ๋ฐํ์ผ๋ก ๋ฏธ๋ ๊ฐ์ ์์ธกํ๋ ๋ฌธ์ ์ ๋๋ค. ๊ณผ๊ฑฐ์ ๊ด์ธก๋ ๋ฐ์ดํฐ์ ๋ฏธ๋ ๊ฐ ์ฌ์ด์ ํจํด์ ๋ฐ๊ฒฌํด์ผ ํ๋ค๋ ์ ์์ ์ง๋ํ์ต ๋ฌธ์ ๋ก ์ ์๊ฐ ๊ฐ๋ฅํฉ๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ด๋ฒ ์ฅ์์๋ ์ ๊ฒฝ๋ง ๊ตฌ์กฐ์ ๊ธฐ๋ฐํ ์ง๋ํ์ต์ ํตํด ๋ฏธ๋ ๊ฐ์ ์์ธกํ๋ ๋ชจ๋ธ์ ๊ตฌ์ถํด๋ณด๊ฒ ์ต๋๋ค.
์๊ณ์ด ์์ธก์ ๋ค๋ฐฉ๋ฉด์์ ํ์๋ก ํ๋ ๊ธฐ์ ์ ๋๋ค. ๊ฐ์ฅ ๋ํ์ ์ผ๋ก ์๋์ง ๋ถ์ผ๊ฐ ์์ต๋๋ค. ์ ๋ ฅ๋ฐ์ ์์์๋ ํจ์จ์ ์ธ ์๋น์ ๋ ฅ ํ๋ณด๋ฅผ ์ํด ๋ฏธ๋์ ์ ๋ ฅ ์์๋ฅผ ์์ธกํด์ผ ํ๋ฉฐ, ๋์๊ฐ์ค ํ์ฌ๋ ๊ฒ์นจ๊ธฐ ๊ณ ์ฅ ๋ฐ ๊ฒ์นจ๊ธฐ ์นํ ์ ๋ํ ์ ์ ์ ์กฐ์น๋ฅผ ํ๊ธฐ ์ํด ๋ฏธ๋์ ๋์๊ฐ์ค ์ฌ์ฉ๋ ์์ธก ๋ชจ๋ธ์ด ํ์ํฉ๋๋ค. ์ค์ ๋ก ํด๋น ๋ฌธ์ ๋ค์ ์๋ก์ด ๋ชจ๋ธ ๋ฐ๊ตด์ ์ํด ๋ฐ์ดํฐ ๊ฒฝ์ง๋ํ(์ ๋ ฅ, ๋์๊ฐ์ค)๋ก๋ ๊ฐ์ต๊ฐ ๋์ต๋๋ค. ์ด ์ธ์๋ ์ ํต ๋ถ์ผ์์๋ ํจ์จ์ ์ธ ๋ฌผํ ๊ด๋ฆฌ๋ฅผ ์ํด ํ๋ชฉ๋ณ ํ๋งค๋ ์์ธก์ ๊ด์ฌ์์ผ๋ฉฐ, ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ์ดํฐ ๊ฒฝ์ง๋ํ(์ ํต)๋ก๋ ๊ฐ์ต๊ฐ ๋์ต๋๋ค.
์ด๋ฒ ํํ ๋ฆฌ์ผ์์๋ Johns Hopkins University์ Center for Systems Science and Engineering์์ ์ ๊ณตํ๋ ์ฝ๋ก๋ ํ์ง์ ๋ฐ์ดํฐ๋ฅผ ํ์ฉํด ๊ณผ๊ฑฐ ํ์ง์ ๋ฐ์ดํฐ๋ฅผ ๋ฐํ์ผ๋ก ๋ฏธ๋ ํ์ง์๋ฅผ ์์ธกํ๋ ๋ชจ๋ธ์ ๊ตฌ์ถํด๋ณด๊ฒ ์ต๋๋ค. 1์ฅ์์๋ ์๊ณ์ด ์์ธก ๋ชจ๋ธ ๊ตฌ์ถ ์ ์ฌ์ฉ ๊ฐ๋ฅํ ์ ๊ฒฝ๋ง ๊ตฌ์กฐ์ ๋ํด ์์ ๋ณผ ๊ฒ์ด๋ฉฐ, ๋ชจ๋ธ ์ฑ๋ฅ ํ๊ฐ ์ ์ฌ์ฉ ๊ฐ๋ฅํ ํ๊ฐ์งํ๋ฅผ ํ์ธํด๋ณด๊ฒ ์ต๋๋ค. 2์ฅ์์๋ ๋ฐ์ดํฐ ํ์์ ๋ถ์์ ํตํด ์ฝ๋ก๋ ํ์ง์ ๋ฐ์ดํฐ์ ๋ํ ์ดํด๋ฅผ ์ฌํ์ํฌ ๊ฒ์ด๋ฉฐ 3์ฅ์์๋ ์๊ณ์ด ๋ฐ์ดํฐ๋ฅผ ์ง๋ํ์ต์ ์ํ ๋ฐ์ดํฐ ํ์์ผ๋ก ๋ฐ๊พธ๋ ๋ฒ์ ์์๋ณผ ๊ฒ์ ๋๋ค. 4์ฅ๊ณผ 5์ฅ์์๋ ๊ฐ๊ฐ ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ํ์ฉํด ๋ฏธ๋ ํ์ง์๋ฅผ ์์ธกํด๋ณด๊ฒ ์ต๋๋ค.
1.1 ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฅ๋ฌ๋ ๊ตฌ์กฐยถ
1.1.1 CNNยถ
๊ทธ๋ฆผ 1-1 CNN ์ ์ฉ ์์ (์ถ์ฒ: Lim et al. 2020. Time Series Forecasting With Deep Learning: A Survey)
์ผ๋ฐ์ ์ผ๋ก CNN์ ์ปดํจํฐ ๋น์ ๋ฌธ์ ์์ ์ฐ์ํ ์ฑ๋ฅ์ ๋ณด์ด๋ ๋คํธ์ํฌ ๊ตฌ์กฐ์ ๋๋ค. ํ๋ ์๊ณ์ด ์์ธก์์๋ CNN ์ ์ฉ์ด ๊ฐ๋ฅํฉ๋๋ค. 1์ฐจ์ Convolution ํํฐ๋ฅผ ํ์ฉํด ์ ๋ ฅ๋๋ sequence ๋ฐ์ดํฐ๊ฐ์ ๊ฐ์คํฉ(weighted sum)์ ๊ตฌํ์ฌ ์์ธก ๋์์ธ ๋ฏธ๋ ๊ฐ์ ์ฐ์ถํ ์ ์์ต๋๋ค. ํ๋ CNN ๊ตฌ์กฐ๋ ๊ณผ๊ฑฐ์ ๋ฏธ๋ ๋ฐ์ดํฐ๊ฐ์ ์๊ฐ์ ์ธ ์์กด์ฑ์ ๋ํด์๋ ๊ณ ๋ คํ์ง ์์ต๋๋ค.
1.1.2 RNNยถ
๊ทธ๋ฆผ 1-2 RNN ์ ์ฉ ์์ (์ถ์ฒ: Lim et al. 2020. Time Series Forecasting With Deep Learning: A Survey)
RNN์ ์์ฐ์ด ์ฒ๋ฆฌ ๋ฌธ์ ์์ ์์ฃผ ํ์ฉ๋๋ ๊ตฌ์กฐ๋ก์จ ์ด์ ์ํ์ ์ ๋ณด๊ฐ ์ถ์ ๋ ์๋ ์ํ(hidden state) ์ ๋ณด๋ฅผ ํ์ฉํด ๋ฏธ๋ ์์ธก์ ํ์ฉํฉ๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๊ณผ๊ฑฐ์ ์ ๋ณด๋ฅผ ํ์ฉํด ๋ฏธ๋์ ์์ธก๊ฐ์ ์ฐ์ถ ํ ์ ์์ต๋๋ค. ํ์ง๋ง ์ฃผ์ด์ง๋ ์ ๋ ฅ sequence๊ฐ ๋๋ฌด ๋ฐฉ๋ํ ๊ฒฝ์ฐ ๋ชจ๋ธ ํ์ต์ ์ ์ํฅ์ ๋ฏธ์น๋ vanishing gradient ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ํด๋น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ LSTM ๊ตฌ์กฐ๋ฅผ ์ฃผ๋ก ํ์ฉํ๊ณ ์์ผ๋ฉฐ, ์ด๋ฒ ํํ ๋ฆฌ์ผ์์๋ LSTM ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ ์์ ์ ๋๋ค.
1.1.3 Attention Mechanismยถ
๊ทธ๋ฆผ 1-3 Attention Mechanism ์ ์ฉ ์์ (์ถ์ฒ: Lim et al. 2020. Time Series Forecasting With Deep Learning: A Survey)
๊ณผ๊ฑฐ ์ ๋ณด๋ณ ๋ฏธ๋ ์์ธก์ ๋์๋๋ ์ ๋ณด์ ๋์์ด ๋์ง ์๋ ์ ๋ณด๊ฐ ์์ ๊ฒ์ ๋๋ค. ์๋ฅผ ๋ค์ด ์ ํต์ ์๊ฐ ์ฃผ๋ง ๋งค์ถ์ ์์ธกํ๊ณ ์ ํ ์์๋ ํ๋ฃจ ์ ๋ ์ธ ํ์ผ์ ๋งค์ถ ๋ณด๋ค๋ ์ผ์ฃผ์ผ ์ ์ ๊ฐ์ ๋ ์ธ ์ฃผ๋ง ๋งค์ถ์ ๊ณ ๋ คํ๋ ๊ฒ์ด ๋์ ๋ ์ ์์ต๋๋ค. Attention ๋ฉ์ปค๋์ฆ์ ํ์ฉํ๋ค๋ฉด ์ด๋ฌํ ์์ธก์ด ๊ฐ๋ฅํด์ง๋๋ค. ๊ณผ๊ฑฐ ์์ ๋ณ ์์ธก ํ๊ณ ์ ํ๋ ์์ ์ ๋ฏธ์น๋ ์ํฅ๋ ฅ์ ์ฐ์ถํด์ ๋ฏธ๋ ๊ฐ ์์ธก ์ ์ฌ์ฉํ๊ฒ ๋ฉ๋๋ค. ์์ธกํ๊ณ ์ ํ๋ ์์ ๊ณผ ๊ณผ๊ฑฐ์ ์๋ ๊ฐ ์ค์ ์ง์ ์ ์ผ๋ก ์ฐ๊ด ์๋ ๊ฐ์ ๋ ๋ง์ ๊ฐ์ค์น๋ฅผ ๋ถ์ฌํจ์ผ๋ก์จ ๋ณด๋ค ์ ํํ ์์ธก์ด ๊ฐ๋ฅํฉ๋๋ค.
1.2 ํ๊ฐ์งํยถ
์ด๋ฒ ํํ ๋ฆฌ์ผ์์๋ ์ฝ๋ก๋ ํ์ง์ ์์ธก ๋ชจ๋ธ์ ๊ตฌ์ถํด๋ณผ ์์ ์ ๋๋ค. ํ์ง์๋ ์ฐ์๋ ๊ฐ์ ์ง๋๊ณ ์๊ธฐ ๋๋ฌธ์ ์์ธก ๋ ๊ฐ๊ณผ ์ค์ ๊ฐ ์ฌ์ด์ ์ฐจ์ด ๊ฐ์ ํตํด ๋ชจ๋ธ์ ์ฑ๋ฅ์ ๊ฐ๋ ํ ์ ์์ต๋๋ค. ์ด๋ฒ ์ ์์๋ ์์ธก ๊ฐ๊ณผ ์ค์ ๊ฐ ์ฌ์ด์ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ๋ ๋ค์ํ ๋ฐฉ๋ฒ์ ์์๋ณด๊ฒ ์ต๋๋ค. ํ๊ฐ์งํ๋ฅผ ์ค๋ช ํ๊ธฐ์ ์์ ์ฌ๋ฌ ๊ธฐํธ๋ค์ ๋ํ ์ ์๋ฅผ ๋จผ์ ์ค์ํ๊ฒ ์ต๋๋ค.
\(y_i\): ์์ธก ๋์์ธ ์ค์ ๊ฐ
\(\hat{y}_i\): ๋ชจ๋ธ์ ์ํ ์์ธก ๊ฐ
\(n\): ์ํ ๋ฐ์ดํฐ์ (test dataset)์ ํฌ๊ธฐ
1.2.1์ ๋ถํฐ 1.2.4์ ๊น์ง๋ ์์ ๊ธฐํธ๋ฅผ ์ฌ์ฉํ๋ฉฐ, 1.2.5์ ์์๋ ๊ธฐํธ ์ ์๊ฐ ๋ฌ๋ผ์ง๊ฒ ๋๋ฏ๋ก ์ด ์ ์ ์ฃผ์ ๋ถํ๋๋ฆฝ๋๋ค.
1.2.1 MAE (Mean Absolute Error)ยถ
\(MAE=\frac{1}{n}\displaystyle\sum_{i=1}^{n} |y_i-\hat{y}_i|\)
L1 Loss๋ก๋ ๋ถ๋ฆฌ๋ MAE๋ ์์ธกํ ๊ฐ๊ณผ ์ค์ ๊ฐ์ ์ฐจ์ด์ ์ ๋๊ฐ์ ์ทจํด ๋ชจ๋ ๋ํด์ฃผ๊ณ ๋์ ๊ณ์ฐํ ์ํ ๊ฐฏ์(n)๋ก ๋๋ ์ ๊ตฌํ ์ ์์ต๋๋ค. ์ํ ๊ฐฏ์ ๋งํผ ๋ชจ๋ ๋ํ ํ ๋๋ ์ค๋ค๋ ๊ฒ์ ํ๊ท ์ ๊ตฌํ๋ค๋ ๊ฒ์ด๋ฏ๋ก, ์์ผ๋ก ๋์ค๋ ํ๊ฐ์งํ๋ค์ ๋ํด์๋ ํ๊ท ์ ๊ตฌํ๋ค๋ ํํ์ ์ฌ์ฉํ๊ฒ ์ต๋๋ค. MAE์ ์ค์ผ์ผ(scale)์ ์์ธก ๋์์ธ ํ๊ฒ ๋ณ์์ ๊ฐ์ ์ค์ผ์ผ์ด๊ธฐ ๋๋ฌธ์ ๊ฐ์ด ๋ดํฌํ๋ ์๋ฏธ๋ฅผ ์ง๊ด์ ์ผ๋ก ์ดํดํ๊ธฐ์ ์ข์ต๋๋ค. ์ฝ๋๋ก ๊ตฌํํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
import numpy as np #๋ํ์ด ํจํค์ง ๋ถ๋ฌ์ค๊ธฐ
def MAE(true, pred):
'''
true: np.array
pred: np.array
'''
return np.mean(np.abs(true-pred))
TRUE = np.array([10, 20, 30, 40, 50])
PRED = np.array([30, 40, 50, 60, 70])
MAE(TRUE, PRED)
20.0
1.2.2 MSE (Mean Squared Error)ยถ
\(MSE=\frac{1}{n}\displaystyle\sum_{i=1}^{n} (y_i-\hat{y}_i)^2\)
\(RMSE=\sqrt{\frac{1}{n}\displaystyle\sum_{i=1}^{n} (y_i-\hat{y}_i)^2}\)
L2 Loss๋ก๋ ๋ถ๋ฆฌ๋ MSE๋ ์์ธก๊ฐ๊ณผ ์ค์ ๊ฐ์ ์ฐจ์ด๋ฅผ ์ ๊ณฑํ์ฌ ์ฐ์ถํ ํ ํ๊ท ์ ๊ตฌํ ๊ฐ์ ๋๋ค. ์์ธก๊ฐ์ด ์ค์ ๊ฐ์์ ๋ ๋ง์ด ๋ฒ์ด๋ ์๋ก MSE ๊ฐ์ ๊ธฐํ ๊ธ์์ ์ผ๋ก ์ฆ๊ฐํ๋ ํน์ฑ์ ์ง๋๋๋ค. ์ฐ์ถ๋ ๊ฐ์ ์ ๊ณฑ์ด ๋์๊ธฐ ๋๋ฌธ์ ํ๊ฒ ๋ณ์์ ๊ฐ์ ์ค์ผ์ผ์ด ๋ค๋ฆ ๋๋ค. ํ๊ฒ ๋ณ์์ ์ค์ผ์ผ์ ๋ง์ถฐ์ฃผ๊ธฐ ์ํด์๋ MSE๊ฐ์ ๋ฃจํธ๋ฅผ ์์์ค ์ ์์ผ๋ฉฐ ์ด ๊ฐ์ RMSE๋ผ๊ณ ๋ถ๋ฆ ๋๋ค. ์ฝ๋๋ก ๊ตฌํํ๋ฉด ์๋์ ๊ฐ์ต๋๋ค.
def MSE(true, pred):
'''
true: np.array
pred: np.array
'''
return np.mean(np.square(true-pred))
TRUE = np.array([10, 20, 30, 40, 50])
PRED = np.array([30, 40, 50, 60, 70])
MSE(TRUE, PRED)
400.0
1.2.3 MAPE (Mean Absolute Percentage Error)ยถ
\(MAPE=\frac{1}{n}\displaystyle\sum_{i=1}^{n} |\frac{y_i-\hat{y}_i}{y_i}|\)
(์ถ์ฒ: https://en.wikipedia.org/wiki/Mean_absolute_percentage_error)
MAPE๋ ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ ์ฌ์ด์ ์ฐจ์ด๋ฅผ ์ค์ ๊ฐ์ผ๋ก ๋๋ ์ค์ผ๋ก์จ ์ค์ฐจ๊ฐ ์ค์ ๊ฐ์์ ์ฐจ์งํ๋ ์๋์ ์ธ ๋น์จ์ ์ฐ์ถํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ํด๋น ๊ฐ์ ์ ๋๊ฐ ์ทจํ ํ ํ๊ท ์ ๊ตฌํฉ๋๋ค. ์ค์ฐจ์ ์ ๋๋ฅผ ๋ฐฑ๋ถ์จ ๊ฐ์ผ๋ก ๋ํ๋ด๊ธฐ ๋๋ฌธ์ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ์ง๊ด์ ์ผ๋ก ์ดํดํ๊ธฐ ์ฌ์ฐ๋ฉฐ, ํ๊ฒ ๋ณ์๊ฐ ์ฌ๋ฌ๊ฐ ์ผ ๋ ๊ฐ ๋ณ์๋ณ ๋ชจ๋ธ์ ์ฑ๋ฅ์ ํ๊ฐํ๊ธฐ ์ฉ์ดํฉ๋๋ค.
ํ์ง๋ง ์ค์ ๊ฐ์ 0์ด ์กด์ฌํ๋ค๋ฉด MAPE๊ฐ ์ ์ ๋์ง ์๋ ๋ฌธ์ ์ ์ด ์์ต๋๋ค. ๋ํ ์ ๋์ ์ธ ๊ฐ์ ์ค์ฐจ๊ฐ ๊ฐ๋๋ผ๋ ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ๊ณผ์ ๋์ ๊ด๊ณ์ ๋ฐ๋ผ ๊ณผ๋ ์ถ์ ํ๋ ์์ธก๊ฐ์ ํจ๋ํฐ๋ฅผ ๋ ๋ถ์ฌํ๋ ๋ฌธ์ ๊ฐ ์์ต๋๋ค(Makridakis, 1993). ์ด๋ ์๋ ์ฝ๋๋ฅผ ํตํด ํ์ธํด๋ณด๊ฒ ์ต๋๋ค.
def MAPE(true, pred):
'''
true: np.array
pred: np.array
'''
return np.mean(np.abs((true-pred)/true))
TRUE_UNDER = np.array([10, 20, 30, 40, 50])
PRED_OVER = np.array([30, 40, 50, 60, 70])
TRUE_OVER = np.array([30, 40, 50, 60, 70])
PRED_UNDER = np.array([10, 20, 30, 40, 50])
print('ํ๊ท ์ค์ฐจ๊ฐ 20์ผ ๋ ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ์ ๋์ ๊ด๊ณ์ ๋ฐ๋ฅธ MAE, MAPE ๋น๊ต \n')
print('์ค์ ๊ฐ์ด ์์ธก๊ฐ ๋ณด๋ค ์์ ๋ (์์ธก๊ฐ์ด ๊ณผ๋์ถ์ )')
print('MAE:', MAE(TRUE_UNDER, PRED_OVER))
print('MAPE:', MAPE(TRUE_UNDER, PRED_OVER))
print('\n์ค์ ๊ฐ์ด ์์ธก๊ฐ ๋ณด๋ค ํด ๋ (์์ธก๊ฐ์ด ๊ณผ์์ถ์ )')
print('MAE:', MAE(TRUE_OVER, PRED_UNDER))
print('MAPE:', MAPE(TRUE_OVER, PRED_UNDER))
ํ๊ท ์ค์ฐจ๊ฐ 20์ผ ๋ ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ์ ๋์ ๊ด๊ณ์ ๋ฐ๋ฅธ MAE, MAPE ๋น๊ต
์ค์ ๊ฐ์ด ์์ธก๊ฐ ๋ณด๋ค ์์ ๋ (์์ธก๊ฐ์ด ๊ณผ๋์ถ์ )
MAE: 20.0
MAPE: 0.9133333333333333
์ค์ ๊ฐ์ด ์์ธก๊ฐ ๋ณด๋ค ํด ๋ (์์ธก๊ฐ์ด ๊ณผ์์ถ์ )
MAE: 20.0
MAPE: 0.4371428571428571
MAPE๋ ์ฐ์ ํน์ฑ ์ ๋ฐฑ๋ถ์จ๋ก ๋ณํํ๊ธฐ ์ํด์ ์ค์ ๊ฐ์ธ \(y\)๋ก ๋๋ ์ฃผ๋ ๋ฐฉ๋ฒ์ ์ทจํ๊ณ ์์ต๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ๋์ถ๋๋ ๊ฐ์ด \(y\)์ ์์กด์ ์ธ ํน์ฑ์ ์ง๋๊ณ ์์ต๋๋ค. ๋ถ์๊ฐ ๊ฐ๋๋ผ๋ ๋ถ๋ชจ๊ฐ ๋ ์์์ง๋ฉด ์ค์ฐจ๊ฐ ์ปค์ง๊ฒ ๋ฉ๋๋ค.
์์ ์ฝ๋์์๋ ์ค์ ๊ฐ์ด ์์ธก๊ฐ๋ณด๋ค 20 ๋งํผ ์์ (TRUE_UNDER
, PRED_OVER
)์ 20 ๋งํผ ํฐ (TRUE_OVER
, PRED_UNDER
)๋ฅผ ํตํด ์ด๋ฅผ ํ์ธํ์ต๋๋ค. MAE ๊ฐ์ TRUE_UNDER
์ PRED_OVER
, ๊ทธ๋ฆฌ๊ณ TRUE_OVER
์ PRED_UNDER
๋ชจ๋ 20์ผ๋ก ๊ฐ์ต๋๋ค. ํ์ง๋ง MAPE๋ ์ค์ ๊ฐ์ด TRUE_UNDER
์ผ ๊ฒฝ์ฐ 0.913, TRUE_OVER
์ผ ๊ฒฝ์ฐ 0.437๋ฅผ ์ฐ์ถํ๊ณ ์์ต๋๋ค.
1.2.4 SMAPE (Symmetric Mean Absolute Percentage Error)ยถ
\(SMAPE=\frac{100}{n}\displaystyle\sum_{i=1}^{n} \frac{|y_i-\hat{y}_i|}{|y_i| + |\hat{y}_i|}\)
(์ถ์ฒ: https://en.wikipedia.org/wiki/Symmetric_mean_absolute_percentage_error)
SMAPE๋ ์์ ์ธ๊ธํ ์์์ ๋ํด MAPE๊ฐ ์ง๋ ํ๊ณ์ ์ ๋ณด์ํ๊ธฐ ์ํด ๊ณ ์๋์ต๋๋ค(Makridakis, 1993). ์๋ ์ฝ๋๋ฅผ ํตํด ํ์ธํด๋ณด๊ฒ ์ต๋๋ค.
def SMAPE(true, pred):
'''
true: np.array
pred: np.array
'''
return np.mean((np.abs(true-pred))/(np.abs(true) + np.abs(pred))) #100์ ์์์ด๋ฏ๋ก ์ด๋ฒ ์ฝ๋์์๋ ์ ์ธ
print('ํ๊ท ์ค์ฐจ๊ฐ 20์ผ ๋ ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ์ ๋์ ๊ด๊ณ์ ๋ฐ๋ฅธ MAE, SMAPE ๋น๊ต \n')
print('์ค์ ๊ฐ์ด ์์ธก๊ฐ ๋ณด๋ค ์์ ๋ (์์ธก๊ฐ์ด ๊ณผ๋์ถ์ )')
print('MAE:', MAE(TRUE_UNDER, PRED_OVER))
print('SMAPE:', SMAPE(TRUE_UNDER, PRED_OVER))
print('\n์ค์ ๊ฐ์ด ์์ธก๊ฐ ๋ณด๋ค ํด ๋ (์์ธก๊ฐ์ด ๊ณผ์์ถ์ )')
print('MAE:', MAE(TRUE_OVER, PRED_UNDER))
print('SMAPE:', SMAPE(TRUE_OVER, PRED_UNDER))
ํ๊ท ์ค์ฐจ๊ฐ 20์ผ ๋ ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ์ ๋์ ๊ด๊ณ์ ๋ฐ๋ฅธ MAE, SMAPE ๋น๊ต
์ค์ ๊ฐ์ด ์์ธก๊ฐ ๋ณด๋ค ์์ ๋ (์์ธก๊ฐ์ด ๊ณผ๋์ถ์ )
MAE: 20.0
SMAPE: 0.29
์ค์ ๊ฐ์ด ์์ธก๊ฐ ๋ณด๋ค ํด ๋ (์์ธก๊ฐ์ด ๊ณผ์์ถ์ )
MAE: 20.0
SMAPE: 0.29
MAPE๋ 0.91, 0.43์ ๋ค๋ฅธ ๊ฐ์ ์ฐ์ถํ์ง๋ง SMAPE๋ 0.29์ ๊ฐ์ ๊ฐ์ ์ฐ์ถํ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค. ํ์ง๋ง SMAPE๋ ๋ถ๋ชจ์ ์์ธก๊ฐ \(\hat{y}_i\)์ด ๋ค์ด๊ฐ์ \(\hat{y}_i\)์ ์์กด์ ์ธ ํน์ฑ์ ์ง๋๊ณ ์์ต๋๋ค. ์์ธก๊ฐ์ด ๊ณผ์์ถ์ ํ ๋ ๋ถ๋ชจ๊ฐ ๋ ์์์ง๋ฏ๋ก ๊ณ์ฐ๋๋ ์ค์ฐจ๊ฐ ์ปค์ง๋ ํ์์ด ๋ฐ์ํฉ๋๋ค. ์๋ ์ฝ๋๋ฅผ ํตํด ํ์ธํด๋ณด๊ฒ ์ต๋๋ค.
TRUE2 = np.array([40, 50, 60, 70, 80])
PRED2_UNDER = np.array([20, 30, 40, 50, 60])
PRED2_OVER = np.array([60, 70, 80, 90, 100])
print('ํ๊ท ์ค์ฐจ๊ฐ 20์ผ ๋ ๊ณผ์์ถ์ , ๊ณผ๋์ถ์ ์ ๋ฐ๋ฅธ MAE, SMAPE ๋น๊ต \n')
print('๊ณผ๋์ถ์ ์')
print('MAE:', MAE(TRUE2, PRED2_OVER))
print('SMAPE:', SMAPE(TRUE2, PRED2_OVER))
print('\n๊ณผ์์ถ์ ์')
print('MAE:', MAE(TRUE2, PRED2_UNDER))
print('SMAPE:', SMAPE(TRUE2, PRED2_UNDER))
ํ๊ท ์ค์ฐจ๊ฐ 20์ผ ๋ ๊ณผ์์ถ์ , ๊ณผ๋์ถ์ ์ ๋ฐ๋ฅธ MAE, SMAPE ๋น๊ต
๊ณผ๋์ถ์ ์
MAE: 20.0
SMAPE: 0.14912698412698414
๊ณผ์์ถ์ ์
MAE: 20.0
SMAPE: 0.21857142857142856
PRED2_UNDER
์ PRED2_OVER
๋ชจ๋ TRUE2
์ ํ๊ท 20์ ์ค์ฐจ๋ฅผ ์ง๋๊ณ ์์ง๋ง, SMAPE๋ ๊ณผ์์ถ์ ํ PRED2_UNDER
์ ๋ํด 0.218์ ๊ฐ์ ๊ณ์ฐํ๋ ๋ฐ๋ฉด ๊ณผ๋์ถ์ ํ PRED2_OVER
์ ๋ํด์๋ 0.149์ ๊ฐ์ ๊ณ์ฐํฉ๋๋ค.
1.2.5 RMSSE (Root Mean Squared Scaled Error)ยถ
\(RMSSE=\sqrt{\displaystyle\frac{\frac{1}{h}\sum_{i=n+1}^{n+h} (y_i-\hat{y}_i)^2}{\frac{1}{n-1}\sum_{i=2}^{n} (y_i-y_{i-1})^2}}\)
RMSSE ์ฐ์์ ๊ธฐํธ ์ ์ ๋ถํฐ ์งํํ๊ฒ ์ต๋๋ค. ๊ฐ๊ฐ์ ๊ธฐํธ๋ ์๋์ ๊ฐ์ ์๋ฏธ๋ฅผ ์ง๋๊ณ ์์ต๋๋ค.
\(y_i\): ์์ธก ๋์์ธ ์ค์ ๊ฐ
\(\hat{y}_i\): ๋ชจ๋ธ์ ์ํ ์์ธก ๊ฐ
\(n\): ํ๋ จ ๋ฐ์ดํฐ์ (train dataset)์ ํฌ๊ธฐ
\(h\): ์ํ ๋ฐ์ดํฐ์ (test dataset)์ ํฌ๊ธฐ
RMSSE๋ Mean Absolute Scaled Error(Hyndman, 2006)์ ๋ณํ๋ ํํ๋ก์จ ์์ ์ธ๊ธํ MAPE์ SMAPE๊ฐ ์ง๋ ๋ฌธ์ ์ ์ ํด๊ฒฐํฉ๋๋ค. MAPE์ SMAPE๋ MAE๋ฅผ ์ค์ผ์ผ๋ง(scaling)ํ๊ธฐ ์ํด ์ํ ๋ฐ์ดํฐ์ ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ์ ํ์ฉํ๊ธฐ ๋๋ฌธ์ ์ค์ฐจ์ ์ ๋๊ฐ์ด ๊ฐ์๋ ๊ณผ์, ๊ณผ๋์ถ์ ์ฌ๋ถ์ ๋ฐ๋ผ ํจ๋ํฐ๊ฐ ๋ถ๊ท ๋ฑํ๊ฒ ๋ถ์ฌ๋ฉ๋๋ค.
RMSSE๋ MSE๋ฅผ ์ค์ผ์ผ๋ง ํ ๋ ํ๋ จ ๋ฐ์ดํฐ๋ฅผ ํ์ฉํ๋ฏ๋ก ์ด๋ฌํ ๋ฌธ์ ์์ ๋ฒ์ด๋ฉ๋๋ค. ํ๋ จ ๋ฐ์ดํฐ์ ๋ํด naive forecasting์ ํ์ ๋์ MSE ๊ฐ์ผ๋ก ๋๋ ์ฃผ๊ธฐ ๋๋ฌธ์ ๋ชจ๋ธ ์์ธก๊ฐ์ ๊ณผ์, ๊ณผ๋ ์ถ์ ์ ๋ฐ๋ผ ์ค์ฐจ ๊ฐ์ด ์ํฅ์ ๋ฐ์ง ์์ต๋๋ค. naive forecast ๋ฐฉ๋ฒ์ ๊ฐ์ฅ ์ต๊ทผ ๊ด์ธก๊ฐ์ผ๋ก ์์ธกํ๋ ๋ฐฉ๋ฒ์ผ๋ก, ์๋์ ๊ฐ์ด ์ ์๋ฉ๋๋ค.
\(\hat{y}_i = y_{i-1}\)
\(i\) ์์ ์ ์์ธก๊ฐ์ \(i-1\) ์์ ์ ์ค์ ๊ฐ์ผ๋ก ์์ธกํ๋ ๋ฐฉ๋ฒ์ ๋๋ค. naive forecast ๋ฐฉ๋ฒ์ ๋ํ MSE๊ฐ์ผ๋ก ๋๋ ์ฃผ๊ธฐ ๋๋ฌธ์, RMSSE๊ฐ์ด 1๋ณด๋ค ํฌ๋ฉด naive forecast ๋ฐฉ๋ฒ๋ณด๋ค ์์ธก์ ๋ชปํ๋ค๋ ๋ป์ด๋ฉฐ 1๋ณด๋ค ์ ์ผ๋ฉด naive forecast ๋ฐฉ๋ฒ๋ณด๋ค ์์ธก์ ์ํ๋ค๋ ์๋ฏธ๋ฅผ ์ง๋๋๋ค. ์๋ ์ฝ๋๋ฅผ ํตํด RMSSE๋ฅผ ๊ตฌํํด๋ณด๊ฒ ์ต๋๋ค.
def RMSSE(true, pred, train):
'''
true: np.array
pred: np.array
train: np.array
'''
n = len(train)
numerator = np.mean(np.sum(np.square(true - pred)))
denominator = 1/(n-1)*np.sum(np.square((train[1:] - train[:-1])))
msse = numerator/denominator
return msse ** 0.5
TRAIN = np.array([10, 20, 30, 40, 50]) #RMSSE ๊ณ์ฐ์ ์ํ ์์์ ํ๋ จ ๋ฐ์ดํฐ์
์์ฑ
print(RMSSE(TRUE_UNDER, PRED_OVER, TRAIN))
print(RMSSE(TRUE_OVER, PRED_UNDER, TRAIN))
print(RMSSE(TRUE2, PRED2_OVER, TRAIN))
print(RMSSE(TRUE2, PRED2_UNDER, TRAIN))
4.47213595499958
4.47213595499958
4.47213595499958
4.47213595499958
์ค์ฐจ์ ์ ๋๊ฐ์ด ๊ฐ์ง๋ง MAPE์ SMAPE๊ฐ ๋ถ๊ท ๋ฑํ๊ฒ ํจ๋ํฐ๋ฅผ ๋ถ์ฌํ๋ 4๊ฐ์ ์์์ ๋ํด ๊ท ๋ฑํ๊ฒ ํจ๋ํฐ๊ฐ ๋ถ์ฌ๋ฌ์ผ๋ฉฐ ์ค์ผ์ผ๋ง๋ ์ด๋ค์ง๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
์ง๊ธ๊น์ง ์๊ณ์ด ์์ธก์ ์ฌ์ฉ๊ฐ๋ฅํ ๋ฅ๋ฌ๋ ๊ตฌ์กฐ์ ํ๊ฐ์งํ์ ๋ํด ์์๋ณด์์ต๋๋ค. ๋ค์ ์ฅ์์๋ ๋ชจ๋ธ ๊ตฌ์ถ์ ํ์ฉํ ์ฝ๋ก๋ ํ์ง์ ๋ฐ์ดํฐ์ ์ ํ์ํด๋ณด๊ฒ ์ต๋๋ค.