1. Time Series ์†Œ๊ฐœยถ

Open In Colab

์‹œ๊ณ„์—ด ์˜ˆ์ธก์€ ๊ณผ๊ฑฐ์— ๊ด€์ธก๋œ ๊ฐ’์„ ๋ฐ”ํƒ•์œผ๋กœ ๋ฏธ๋ž˜ ๊ฐ’์„ ์˜ˆ์ธกํ•˜๋Š” ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค. ๊ณผ๊ฑฐ์— ๊ด€์ธก๋œ ๋ฐ์ดํ„ฐ์™€ ๋ฏธ๋ž˜ ๊ฐ’ ์‚ฌ์ด์˜ ํŒจํ„ด์„ ๋ฐœ๊ฒฌํ•ด์•ผ ํ•œ๋‹ค๋Š” ์ ์—์„œ ์ง€๋„ํ•™์Šต ๋ฌธ์ œ๋กœ ์ •์˜๊ฐ€ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ ‡๊ธฐ ๋•Œ๋ฌธ์— ์ด๋ฒˆ ์žฅ์—์„œ๋Š” ์‹ ๊ฒฝ๋ง ๊ตฌ์กฐ์— ๊ธฐ๋ฐ˜ํ•œ ์ง€๋„ํ•™์Šต์„ ํ†ตํ•ด ๋ฏธ๋ž˜ ๊ฐ’์„ ์˜ˆ์ธกํ•˜๋Š” ๋ชจ๋ธ์„ ๊ตฌ์ถ•ํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์‹œ๊ณ„์—ด ์˜ˆ์ธก์€ ๋‹ค๋ฐฉ๋ฉด์—์„œ ํ•„์š”๋กœ ํ•˜๋Š” ๊ธฐ์ˆ ์ž…๋‹ˆ๋‹ค. ๊ฐ€์žฅ ๋Œ€ํ‘œ์ ์œผ๋กœ ์—๋„ˆ์ง€ ๋ถ„์•ผ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ์ „๋ ฅ๋ฐœ์ „์†Œ์—์„œ๋Š” ํšจ์œจ์ ์ธ ์˜ˆ๋น„์ „๋ ฅ ํ™•๋ณด๋ฅผ ์œ„ํ•ด ๋ฏธ๋ž˜์˜ ์ „๋ ฅ ์ˆ˜์š”๋ฅผ ์˜ˆ์ธกํ•ด์•ผ ํ•˜๋ฉฐ, ๋„์‹œ๊ฐ€์Šค ํšŒ์‚ฌ๋Š” ๊ฒ€์นจ๊ธฐ ๊ณ ์žฅ ๋ฐ ๊ฒ€์นจ๊ธฐ ์น˜ํŒ…์— ๋Œ€ํ•œ ์„ ์ œ์  ์กฐ์น˜๋ฅผ ํ•˜๊ธฐ ์œ„ํ•ด ๋ฏธ๋ž˜์˜ ๋„์‹œ๊ฐ€์Šค ์‚ฌ์šฉ๋Ÿ‰ ์˜ˆ์ธก ๋ชจ๋ธ์ด ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค. ์‹ค์ œ๋กœ ํ•ด๋‹น ๋ฌธ์ œ๋“ค์€ ์ƒˆ๋กœ์šด ๋ชจ๋ธ ๋ฐœ๊ตด์„ ์œ„ํ•ด ๋ฐ์ดํ„ฐ ๊ฒฝ์ง„๋Œ€ํšŒ(์ „๋ ฅ, ๋„์‹œ๊ฐ€์Šค)๋กœ๋„ ๊ฐœ์ตœ๊ฐ€ ๋์Šต๋‹ˆ๋‹ค. ์ด ์™ธ์—๋„ ์œ ํ†ต ๋ถ„์•ผ์—์„œ๋„ ํšจ์œจ์ ์ธ ๋ฌผํ’ˆ ๊ด€๋ฆฌ๋ฅผ ์œ„ํ•ด ํ’ˆ๋ชฉ๋ณ„ ํŒ๋งค๋Ÿ‰ ์˜ˆ์ธก์— ๊ด€์‹ฌ์žˆ์œผ๋ฉฐ, ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ๋ฐ์ดํ„ฐ ๊ฒฝ์ง„๋Œ€ํšŒ(์œ ํ†ต)๋กœ๋„ ๊ฐœ์ตœ๊ฐ€ ๋์Šต๋‹ˆ๋‹ค.

์ด๋ฒˆ ํŠœํ† ๋ฆฌ์–ผ์—์„œ๋Š” 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๊ฐœ์˜ ์˜ˆ์‹œ์— ๋Œ€ํ•ด ๊ท ๋“ฑํ•˜๊ฒŒ ํŒจ๋„ํ‹ฐ๊ฐ€ ๋ถ€์—ฌ๋ฌ์œผ๋ฉฐ ์Šค์ผ€์ผ๋ง๋„ ์ด๋ค„์ง„๊ฒƒ์„ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ง€๊ธˆ๊นŒ์ง€ ์‹œ๊ณ„์—ด ์˜ˆ์ธก์‹œ ์‚ฌ์šฉ๊ฐ€๋Šฅํ•œ ๋”ฅ๋Ÿฌ๋‹ ๊ตฌ์กฐ์™€ ํ‰๊ฐ€์ง€ํ‘œ์— ๋Œ€ํ•ด ์•Œ์•„๋ณด์•˜์Šต๋‹ˆ๋‹ค. ๋‹ค์Œ ์žฅ์—์„œ๋Š” ๋ชจ๋ธ ๊ตฌ์ถ•์— ํ™œ์šฉํ•  ์ฝ”๋กœ๋‚˜ ํ™•์ง„์ž ๋ฐ์ดํ„ฐ์…‹์„ ํƒ์ƒ‰ํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.