kosis-apt-2006-2021-time-series.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1OmqvI0456pI"
      },
      "source": [
        "# 시계열 분석\n",
        "* 시계열 데이터 : 주가, 환율, 거래량, 판매량, 재고량, 수요량, 클릭률, 기온, 습도, 인구, 출생률, 트래픽양의 피크시간 패턴, 제품의 판매주기, 심장 박동\n",
        "\n",
        "\n",
        "* 시계열 데이터의 특성을 파악\n",
        "    * 규칙적 : 경향(trend), 계절성(seasonality), 주기(cycle)\n",
        "    * 불규칙적 : 불규칙성(irregular, random)\n",
        "\n",
        "#### 시계열의 구성요소\n",
        "  * 추세 - 추세에는 장기간에 걸친 시계열 데이터의 일반적인 방향이 표시됩니다. 추세는 증가(상향), 감소(하향) 또는 수평(정지)일 수 있습니다.\n",
        "  * 계절성 - 계절성 성분은 시기, 방향 및 크기와 관련하여 반복되는 추세를 나타냅니다. 더운 날씨로 인한 여름철 물 소비량 증가가 대표적입니다.\n",
        "  * 순환 성분 - 특정 기간 동안 설정된 반복이 없는 추세입니다. 사이클(cycle)은 주로 경기 순환에서 관찰되는 시계열의 흥망성쇠, 호황, 슬럼화 시기를 가리킵니다. 이러한 주기는 계절적 변화를 나타내지는 않지만, 일반적으로 시계열의 특성에 따라 3~12년에 걸쳐 일어납니다.\n",
        " * 불규칙 변동 - 추세 및 주기적 변동을 제거할 때 분명하게 나타나는 시계열 데이터의 변동입니다. 이러한 변화는 예측할 수 없고 불규칙하며 무작위일 수도 있고 아닐 수도 있습니다.\n",
        "  * ETS(Error, Trend, Seasonality) 분해 - ETS 분해는 시계열의 여러 성분을 구분하는 데 사용됩니다.\n",
        "\n",
        "#### 응용\n",
        "\n",
        "* 추세 파악 \n",
        ": 무작위 적인 소음을 제거하여 흐름을 파악\n",
        "* 원인 예측 및 대응\n",
        ": 수요 분석을 통한 재고량 관리\n",
        "* 전망\n",
        ": 영업 전략, 생산 계획\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JLMLVsje56pM"
      },
      "source": [
        "## 통계청 서울특별시 아파트 거래 현황\n",
        "* 부동산거래현황:행정구역별 아파트거래현황 : https://kosis.kr/statHtml/statHtml.do?orgId=408&tblId=DT_408_2006_S0049&conn_path=I2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iEsqeNAa56pN"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "import plotly.express as px\n",
        "from IPython.display import set_matplotlib_formats\n",
        "\n",
        "import plotly.io as pio\n",
        "pio.renderers.default = \"colab\"\n",
        "\n",
        "def get_font_family():\n",
        "    \"\"\"\n",
        "    시스템 환경에 따른 기본 폰트명을 반환하는 함수\n",
        "    \"\"\"\n",
        "    import platform\n",
        "    system_name = platform.system()\n",
        "\n",
        "    if system_name == \"Darwin\" :\n",
        "        font_family = \"AppleGothic\"\n",
        "    elif system_name == \"Windows\":\n",
        "        font_family = \"Malgun Gothic\"\n",
        "    else:\n",
        "        # Linux(colab)\n",
        "        !apt-get install fonts-nanum -qq  > /dev/null\n",
        "        !fc-cache -fv\n",
        "\n",
        "        import matplotlib as mpl\n",
        "        mpl.font_manager._rebuild()\n",
        "        findfont = mpl.font_manager.fontManager.findfont\n",
        "        mpl.font_manager.findfont = findfont\n",
        "        mpl.backends.backend_agg.findfont = findfont\n",
        "        \n",
        "        font_family = \"NanumBarunGothic\"\n",
        "    return font_family\n",
        "\n",
        "plt.rc('font', family=get_font_family()) \n",
        "plt.rc('axes', unicode_minus=False)\n",
        "\n",
        "set_matplotlib_formats('retina')\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_lWAahgQ56pO"
      },
      "source": [
        "## csv 파일로드"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JEpvmHry56pO"
      },
      "outputs": [],
      "source": [
        "df = pd.read_csv(\"kosis-apt-2006-2021.csv\", encoding=\"cp949\")\n",
        "df.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "arNk1vT856pP"
      },
      "outputs": [],
      "source": [
        "df.head(3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "enZ2kDYz56pP"
      },
      "outputs": [],
      "source": [
        "df.tail(3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "xfzlzogi56pQ"
      },
      "outputs": [],
      "source": [
        "df.info()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jfrqfD1O56pQ"
      },
      "outputs": [],
      "source": [
        "df[\"연도\"] = df[\"시점\"].apply(lambda x : int(x[:4]))\n",
        "df[\"월\"] = df[\"시점\"].apply(lambda x : int(x[5:]))\n",
        "df"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CjVi9kpX56pR"
      },
      "outputs": [],
      "source": [
        "df = df.rename(columns={\"호수 (호수)\": \"거래수\"})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rYcUfAKO56pR"
      },
      "outputs": [],
      "source": [
        "df = df[[\"시점\", \"연도\", \"월\", \"거래수\"]]\n",
        "df.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BdwBNJGr56pS"
      },
      "outputs": [],
      "source": [
        "df.info()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FMyfa7G456pS"
      },
      "outputs": [],
      "source": [
        "df.describe()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dQXA1FgI56pS"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(15, 5))\n",
        "sns.barplot(data=df, x=\"시점\", y=\"거래수\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WzzRSRqj56pT"
      },
      "outputs": [],
      "source": [
        "df.set_index(\"시점\")[\"거래수\"].plot(figsize=(12, 5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "99cY6_ph56pT"
      },
      "outputs": [],
      "source": [
        "df.set_index(\"시점\")[\"거래수\"].plot.bar(figsize=(12, 5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HfCU6m-S56pT"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(15, 5))\n",
        "sns.lineplot(data=df, x=\"연도\", y=\"거래수\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "N5zagyEr56pU"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(15, 5))\n",
        "sns.pointplot(data=df, x=\"연도\", y=\"거래수\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0C-_G8MV56pU"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(15, 5))\n",
        "sns.pointplot(data=df, x=\"월\", y=\"거래수\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-FQeiKIL56pU"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(15, 5))\n",
        "sns.pointplot(data=df, x=\"월\", y=\"거래수\", estimator=np.sum, ci=None)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Gr1ZAXPM56pU"
      },
      "outputs": [],
      "source": [
        "# 수치 데이터를 히스토그램으로 표현\n",
        "# 수치 데이터를 막대그래프로 표현하기 위해서는 도수분포표를 만들고 이를 시각화 하는 것이 히스토그램\n",
        "df.hist(figsize = (15,15), bins=25)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## plotly"
      ],
      "metadata": {
        "id": "KgcpkxydNlSQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fig = px.line(df, x=\"시점\", y=\"거래수\")\n",
        "fig.show(renderer=\"colab\")"
      ],
      "metadata": {
        "id": "rnkWaSCMNj1m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fig = px.bar(df, x=\"시점\", y=\"거래수\")\n",
        "fig.show(renderer=\"colab\")"
      ],
      "metadata": {
        "id": "mvuIva0eOPSq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "## 이동평균\n",
        "통계학에서 이동평균(롤링평균 또는 이동평균)은 전체 데이터 집합의 여러 하위 집합에 대한 일련의 평균을 만들어 데이터 요소를 분석하는 계산이다. 이동산술평균 (Moving Mean) 또는 롤링산술평균(Rolling Mean)이라고도 한다.\n",
        "\n",
        "일련의 연속된 숫자와 고정된 부분 집합 크기가 주어지면, 이동 평균의 첫 번째 요소는 연속된 숫자의 첫 고정 부분 집합의 평균을 취하여 구한다. 그런 다음 \"앞으로 이동\"하여 하위 집합을 변경한다. 즉, 부분 집합의 첫 번째 숫자를 제외하고 연속된 숫자의 다음 값을 포함시킨다.\n",
        "\n",
        "\n",
        "* 출처 : [이동평균 - 위키백과, 우리 모두의 백과사전](https://ko.wikipedia.org/wiki/%EC%9D%B4%EB%8F%99%ED%8F%89%EA%B7%A0)\n",
        "\n",
        "* 이동평균의 종류\n",
        "    * 단순이동평균(Simple Moving Average)\n",
        "    * 누적이동평균(Cumulative moving average)\n",
        "    * 가중이동평균(Weighted Moving Average)\n",
        "    * 지수이동평균(Exponential Moving Average)\n",
        "\n",
        "\n",
        "### rolling\n",
        "* window : 몇 개의 데이터를 가지고 연산을 할 것인지 결정\n",
        "    * 의미 : window가 클수록 부드러운 선의 형태를 가지고 있음 window가 center에 있지 않으면 window는 클수록 위상 차가 큼\n",
        "* min_periods : 최소한 몇 개의 데이터가 있어야 연산을 할 것인지 결정\n",
        "    * --> window 안의 데이터가 min_periods보다 적다면, \n",
        "       결과는 NaN\n",
        "* center : window의 위치를 window 끝으로 할 것인지 중간으로 할 것 인지 결정\n",
        "    * 의미 : 시계열 데이터에서는 window를 중간으로 할 수 없다(미래의 데이터는 볼 수 없기 때문에)\n",
        "* <font color=\"red\">연산을 mean()으로 했을 경우 'rolling'은 전체적으로 진짜 데이터에서 **잡음(noise)을 제거**하는 의미</font>\n",
        "\n",
        "### expanding\n",
        "\n",
        "* window : expanding에서는 window를 결정하지 않음\n",
        "    * 왜냐하면 window의 크기가 순차적으로 증가하기 때문\n",
        "* min_periods : 최소한 몇 개의 데이터가 있어야 연산을 할 것인지 결정\n",
        "    * --> 이것은 rolling과 같음\n",
        "* expanding에서의 sum()은 cumsum() 연산과 동일하게 진행되나 NaN 이 있을 경우 expanding은 무난하게 처리할 수 있음\n",
        "* 연산을 sum()으로 했을 경우, cumsum()과 같은 의미가 있음\n",
        "* <font color=\"red\">연산을 mean()으로 했을 경우 'expanding' 은 전체적으로 **추세**를 찾는 의미가 있음</font>\n",
        "\n",
        "<img src=\"https://i.imgur.com/mCBaCbd.png\">\n",
        "\n"
      ],
      "metadata": {
        "id": "mDnGASmAEHtL"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XA9MLtGg56pV"
      },
      "source": [
        "### 단순이동평균(SMA: Simple Moving Average)\n",
        "* rolling을 사용합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uPup89s-56pV"
      },
      "outputs": [],
      "source": [
        "df[\"시점\"] = pd.to_datetime(df[\"시점\"])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tR3kNQwq56pV"
      },
      "outputs": [],
      "source": [
        "df_ym = df.set_index(\"시점\")[\"거래수\"]\n",
        "df_ym.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "P-jYkR1G56pV"
      },
      "outputs": [],
      "source": [
        "# rolling mean을 구해서 시각화 합니다.\n",
        "rolmean = df_ym.rolling(window=12).mean() \n",
        "rolstd = df_ym.rolling(window=12).std()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Im4nauQC56pV"
      },
      "outputs": [],
      "source": [
        "df_ym.plot(label='Original')\n",
        "rolmean.plot(label='Rolling Mean')\n",
        "rolstd.plot(label='Rolling Std', figsize=(15, 5))\n",
        "\n",
        "plt.legend(loc='best')\n",
        "plt.title('Rolling Mean & Standard Deviation')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R7lP31Rs56pV"
      },
      "source": [
        "## Weighted Moving Average\n",
        "* exponentially-weighted-windows\n",
        "* https://pandas.pydata.org/pandas-docs/stable/user_guide/window.html#exponentially-weighted-window"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JHu4JAOR56pW"
      },
      "outputs": [],
      "source": [
        "df_ym = df_ym.to_frame()\n",
        "df_ym['WMA12'] = df_ym['거래수'].ewm(span=12).mean()\n",
        "df_ym['WMA6'] = df_ym['거래수'].ewm(span=6).mean()\n",
        "df_ym"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L1M4XVxO56pW"
      },
      "outputs": [],
      "source": [
        "df_ym[['거래수', 'WMA6','WMA12']].plot(figsize=(15,5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nN5KF_E156pW"
      },
      "source": [
        "## Simple Exponential Smoothing\n",
        "### 지수이동평균(Exponential Moving Average)\n",
        "* 최근 자료에 가중치를 부여하여 최근 가격 변동을 잘 나타냅니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LsLWJlJq56pW"
      },
      "outputs": [],
      "source": [
        "split_count = int(df_ym.shape[0] * 0.8)\n",
        "split_count"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PlDEmcDO56pW"
      },
      "outputs": [],
      "source": [
        "# 데이터셋을 train과 test 로 나눈다.\n",
        "train = pd.DataFrame(df_ym[:split_count])\n",
        "test = pd.DataFrame(df_ym[split_count:])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UOL1agP056pW"
      },
      "outputs": [],
      "source": [
        "train[\"거래수\"].plot(figsize=(15,5))\n",
        "test[\"거래수\"].plot(title='train과 test세트로 분할')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8H53zSxt56pW"
      },
      "outputs": [],
      "source": [
        "from statsmodels.tsa.api import SimpleExpSmoothing\n",
        "ses_model = SimpleExpSmoothing(np.asarray(train['거래수'].astype(np.float)))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RAr4JDCl56pX"
      },
      "outputs": [],
      "source": [
        "ses_result = ses_model.fit()\n",
        "ses_result"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eyJKRo5Z56pX"
      },
      "outputs": [],
      "source": [
        "y_hat = test.copy()\n",
        "y_hat['SES'] = ses_result.forecast(len(test))\n",
        "y_hat['SES'][:3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uUisoWg756pX"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(15,5))\n",
        "plt.plot(train['거래수'], label='Train')\n",
        "plt.plot(test['거래수'], label='Test')\n",
        "plt.plot(y_hat['SES'], label='Simple Exp Smoothing')\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Tl8hiAtF56pX"
      },
      "outputs": [],
      "source": [
        "rmse = {}\n",
        "# root mean squared error 로 오차를 계산해 본다.\n",
        "rmse[\"SES\"] = np.sqrt(np.square(test['거래수'] - y_hat['SES']).mean())\n",
        "rmse[\"SES\"]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CMzkkICd56pX"
      },
      "source": [
        "## Expanding\n",
        "\n",
        "### 누적이동평균(Cumulative moving average)\n",
        "* expanding을 사용합니다. window 창이 시간의 흐름에 따라 증가합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RaqzyY7C56pY"
      },
      "outputs": [],
      "source": [
        "# Expanding\n",
        "df_ym['거래수'].expanding(min_periods=1).mean().plot(figsize=(15,5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c7IE3Q5g56pY"
      },
      "source": [
        "## Dickey–Fuller test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f2XaOwoW56pY"
      },
      "outputs": [],
      "source": [
        "# 결과의 p-value 가 5%를 벗어나면 non-stationary 데이터\n",
        "# AIC - 회귀에서 예측변수(predictor)를 고를 때 사용하며, 아카이케(Akaike)의 정보 기준(AIC; Akaike’s information Criterion)\n",
        "# AIC 출처 : [8.6 추정과 차수 선택 | Forecasting: Principles and Practice](https://otexts.com/fppkr/arima-estimation.html)\n",
        "from statsmodels.tsa.stattools import adfuller\n",
        "# Perform Dickey–Fuller test:\n",
        "print('Results of Dickey Fuller Test:')\n",
        "dftest = adfuller(df_ym['거래수'], autolag='AIC')\n",
        "dfoutput = pd.Series(\n",
        "    dftest[0:4], \n",
        "    index=['Test Statistic',\n",
        "           'p-value',\n",
        "           '#Lags Used',\n",
        "           'Number of Observations Used'])\n",
        "\n",
        "for key,value in dftest[4].items():\n",
        "    dfoutput['Critical Value (%s)'%key] = value\n",
        "print(dfoutput)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nAZLGHsT56pY"
      },
      "source": [
        "## Time Series data Decomposition(시계열 데이터 분해)\n",
        "* Seasonal\n",
        "* Trend\n",
        "* Residual(random, remainder)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "### 정상 시계열(stationary)\n",
        " * 뚜렷한 추세가 없음\n",
        " * 진폭이 흐름에 따라 일정함\n",
        "\n",
        "### 비정상 시계열(non-stationary)\n",
        " * 평균이 시간대에 따라 다름\n",
        " * 추세, 계절성을 가짐\n",
        " * 분산이 변한다\n",
        " * 분산이 일정하지 않으면 특정 기간에 오류가 발생하고 예측을 하기에 적합하지 않을 수 있다.\n",
        "\n",
        "\n",
        "### 비정상 시계열의 정상화\n",
        "\n",
        "\n",
        "1. 분산이 일정하지 않은 경우 \n",
        " * 분산 안정화 변환(로그변환, 제곱근 변환, Box-Cox 변환)\n",
        "2. 추세가 있을 때\n",
        " * 결정적 추세 : 분해법 또는 추세항 모형에 포함\n",
        " * 확률적 추세(Dickey-Fuller의 단위근 검정): 차분을 이용 Trend 제거\n",
        " * 로그변환(lograithm) : 표준편차가 자료의 크기에 비례 해서 증가 할 때\n",
        "3. 계절성을 가지는 경우\n",
        " * 결정적 계절추세 : 계절 추세항 모형에 포함\n",
        " * 확률적 계절추세(계절형 단위근 검정) : 계절차분 \n",
        " "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rTMHEDJ056pY"
      },
      "source": [
        "## Additive Model\n",
        "\n",
        "* 값을 더해서 구한다.\n",
        "\n",
        "$y_t = Level + Trend + Seasonality + Noise$\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qfbxY0dk56pY"
      },
      "outputs": [],
      "source": [
        "from statsmodels.api import tsa\n",
        "\n",
        "# Additive model\n",
        "res = tsa.seasonal_decompose(df_ym[\"거래수\"], freq=30, model=\"additive\")\n",
        "fig = res.plot()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kh0xaLeG56pY"
      },
      "source": [
        "## Multiplicative Model\n",
        "*  값을 곱해서 구한다.\n",
        "\n",
        "$y_t = Level \\times Trend \\times Seasonality \\times Noise$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "afcEAI9_56pZ"
      },
      "outputs": [],
      "source": [
        "# multiplicative\n",
        "res = tsa.seasonal_decompose(df_ym[\"거래수\"], freq=7, model=\"multiplicative\")\n",
        "fig = res.plot()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WWnaZgrw56pZ"
      },
      "source": [
        "## ACF, PACF\n",
        "* ARIMA 모델 사용시 lag 값에 따른 절단값으로 p,d,q값을 찾기 위해 그려봅니다.\n",
        "* AUTO.ARIMA 함수를 사용하여 최적화된 파라미터를 찾을 수도 있습니다.\n",
        "\n",
        "## ACF : 자기상관 함수 AutoCorrelation Function\n",
        "\n",
        "## PACF : 부분 자기상관 함수 Partial AutoCorrelation Function \n",
        "\n",
        "* p – Lag value where the PACF chart crosses the upper confidence interval for the first time.\n",
        "* q – Lag value where the ACF chart crosses the upper confidence interval for the first time.\n",
        "\n",
        "* 참고 : [Detecting stationarity in time series data - Towards Data Science](https://towardsdatascience.com/detecting-stationarity-in-time-series-data-d29e0a21e638)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YDCNhqia56pZ",
        "collapsed": true
      },
      "outputs": [],
      "source": [
        "from statsmodels.graphics import tsaplots\n",
        "# lag는 0부터 설정할 수 있으나 너무 낮으면  그래프를 보기 어려움\n",
        "# 0은 자기 자신이라 제외하고 봄\n",
        "\n",
        "ax1 = plt.subplot(211)\n",
        "tsaplots.plot_acf(df_ym[\"거래수\"], lags=30, ax=ax1)\n",
        "ax2 = plt.subplot(212)\n",
        "tsaplots.plot_pacf(df_ym[\"거래수\"], lags=30, ax=ax2)\n",
        "plt.tight_layout()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VevKCojR56pZ"
      },
      "source": [
        "## ARIMA\n",
        "\n",
        "* 자동회귀이동평균(ARMA : Autoregressive moving average) 모델의 일반화\n",
        "* 시계열 데이터를 더 잘 이해하거나 미래 지점을 예상(예측)하기에 적합\n",
        "* 데이터가 비정상성이 아닌 증거를 나타내는 경우에 적용되며, **초기 차분 단계(모델의 \"통합된\" 부분에 해당)를 한 번 이상 적용하여 비정상성을 제거** >> 비정상데이터도 다룰 수 있음\n",
        "\n",
        "* AR 부분은 진화하는 관심 변수가 시차(즉, 이전) 값으로 회귀됨을 나타냄\n",
        "* MA 부분은 회귀 오류가 실제로 과거 여러 시간에 동시에 발생한 오류 항의 선형 조합임을 나타냄\n",
        "* I(\"누적\"의 경우)는 데이터 값이 해당 값과 이전 값의 차이로 바뀌 었음을 나타냄\n",
        "\n",
        "<img src = \"https://imgur.com/5sV0YS5.jpg\">\n",
        "\n",
        "## Seasonal ARIMA\n",
        "* 참고 : [An End-to-End Project on Time Series Analysis and Forecasting with Python](https://towardsdatascience.com/an-end-to-end-project-on-time-series-analysis-and-forecasting-with-python-4835e6bf050b)\n",
        "\n",
        "ARIMA(p,d,q)모형은 차수 p, d, q의 값에 따라 다른이름으로 불립니다.\n",
        "\n",
        "- 자동 회귀(p) -> AR모형과 관련\n",
        "      ex) p=0이면, IMA(d,q)모형이라 부르고 d번 차분하면 MA(q)모형을 따르게 됨\n",
        "- 적분(d) -> 정상성에 필요한 비계절차의 수\n",
        "      ex) d=0이면, ARMA(p,q)모형이라 부르고 이 모형은 정상성을 만족한다.\n",
        "- 이동 평균(q) -> 예측 방정식의 지연된 예측 오류 수, MA모형과 관련이 있음\n",
        "      ex) q=0이면, ARI(p,d)모형이라 부르며, d번 차분한 시계열이 AR(p)모형을 따르게 됨\n",
        "\n",
        "\n",
        "### Trend\n",
        "* p: Trend autoregression order. AR(p)모형의 p차수\n",
        "* d: Trend difference order. 트랜드를 제거하여 안정시계열로 만들기 위한 I(d)의 차분 차수 d\n",
        "* q: Trend moving average order. MA(q)의 q차수 \n",
        "\n",
        "### Seasonal\n",
        "* P: Seasonal autoregressive order.\n",
        "* D: Seasonal difference order.\n",
        "* Q: Seasonal moving average order.\n",
        "* m: The number of time steps for a single seasonal period.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Tlkw3tmJ56pZ"
      },
      "outputs": [],
      "source": [
        "import itertools\n",
        "p = d = q = range(0, 2)\n",
        "pdq = list(itertools.product(p, d, q))\n",
        "m = 12\n",
        "print(pdq)\n",
        "seasonal_pdq = [(x[0], x[1], x[2], m) for x in list(itertools.product(p, d, q))]\n",
        "seasonal_pdq"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B-AzVzfS56pZ"
      },
      "outputs": [],
      "source": [
        "# Grid Search와 유사하게 최적의 파라메터 값을 찾는다.\n",
        "y = train['거래수'].to_list()\n",
        "\n",
        "for param in pdq:\n",
        "    for param_seasonal in seasonal_pdq:\n",
        "        try:\n",
        "            mod = tsa.statespace.SARIMAX(y,\n",
        "                                        order=param,\n",
        "                                        seasonal_order=param_seasonal,\n",
        "                                        enforce_stationarity=False,\n",
        "                                        enforce_invertibility=False)\n",
        "            results = mod.fit()\n",
        "            print(f\"ARIMA{param}x{param_seasonal}{m} - AIC:{results.aic}\")\n",
        "        except:\n",
        "            continue"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tZjXkdvV56pa"
      },
      "outputs": [],
      "source": [
        "# ARIMA(p,d,q)(P,D,Q)m\n",
        "arima = tsa.statespace.SARIMAX(train['거래수'].to_list(),\n",
        "                                  order=(1,1,1),\n",
        "                                  seasonal_order=(0,1,1,12),\n",
        "                                  enforce_stationarity=False,\n",
        "                                  enforce_invertibility=False)\n",
        "# 학습\n",
        "arima_result = arima.fit()\n",
        "arima_result.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 잔차 검정\n",
        "잔차가 정상성을 만족(백색소음 과정인지)하는지, 정규성 및 등분산성을 만족하는지 파악합니다.\n",
        "1. summary 결과에서 Ljung-Box(Q) / Heteroskedasticity(H) / Jarque-Bera(JB) 검정 만족 여부를 파악할 수 있습니다.\n",
        "2. plot_diagnostics 잔차 그래프로도 정상성과 정규성을 만족하는지 파악할 수 있습니다.\n",
        "\n",
        "* Ljung-Box(Q) / Heteroskedasticity(H) / Jarque-Bera(JB)에 대한 부분은 모두 잔차에 대한 검정 통계량입니다.\n",
        "  * Ljung-Box(Q)(융-박스 검정 통계량) - 잔차가 백색소음인지 검정한 통계량으로 Prob(Q) 값을 보면 0.79이므로 유의수준 0.05에서 귀무가설을 기각하지 못합니다. Ljung-Box (Q) 통계량의 귀무가설은 “잔차(residual)가 백색소음(white noise) 시계열을 따른다”이므로, 위 결과를 통해 시계열 모형이 잘 적합되었고 남은 잔차는 더이상 자기상관을 가지지 않는 백색소음임을 확인할 수 있습니다.\n",
        "\n",
        "* Jarque-Bera(JB)(자크-베라 검정 통계량)은 잔차가 정규성을 띠는지 검정한 통계량으로, Prob(JB)값을 보면 0.03으로 유의 수준 0.05에서 귀무가설을 기각합니다. Jarque-Bera (JB) 통계량의 귀무가설은 “잔차가 정규성을 만족한다”이므로, 위 결과를 통해 “잔차가 정규성을 따르지 않음”을 확인할 수 있습니다.\n",
        "\n",
        "* Heteroskedasticity(H)(이분산성 검정 통계량)은 잔차가 이분산을 띠지 않는지 검정한 통계량입니다.\n",
        "\n",
        "### 왜도(Skewness)\n",
        "  * 비대칭도(非對稱度, skewness) 또는 왜도(歪度)는 실수 값 확률 변수의 **확률 분포 비대칭성을 나타내는 지표** >> 데이터의 분포가 정규분포에 비해서 얼마나 비대칭인지 나타내는 척도\n",
        "<img src = \"https://upload.wikimedia.org/wikipedia/commons/thumb/c/cc/Relationship_between_mean_and_median_under_different_skewness.png/1024px-Relationship_between_mean_and_median_under_different_skewness.png\">\n",
        "\n",
        "  * 음의 왜도(Negative Skewness): 데이터의 중심(평균)이 정규 분포보다 오른쪽으로 치우쳐져 있고, 꼬리는 왼쪽으로 길게 표현\n",
        "  * 양의 왜도(Positive Skewness): 데이터의 중심(평균)이 정규 분포보다 왼쪽으로 치우쳐져 있고, 꼬리는 오른쪽으로 길게 표현\n",
        "  * 왜도의 값이 -2 미만이면 Negative Skewness, 2 초과이면 Positive Skewness\n",
        "    * 대칭적 데이터: 왜도가 -0.5와 0.5사이\n",
        "    * 적당히 치우친 데이터: 왜도가 -1과 -0.5(음의 치우침) 또는 0.5와 1(양의 치우침) 사이의 값\n",
        "    * 고도로 치우친 데이터: 왜도가 -1보다 작거나(음으로 치우침) 1보다 큰 값(양으로 치우침)\n",
        "\n",
        "* 참조: https://en.wikipedia.org/wiki/Skewness\n"
      ],
      "metadata": {
        "id": "79nyT9ETXynU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "arima_result.summary().tables[1]"
      ],
      "metadata": {
        "id": "xQPO9G-VQxzM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 잔차 검정\n",
        "* `ARIMAResults.plot_diagnostics(variable=0, lags=10, fig=None, figsize=None, truncate_endog_names=24, auto_ylims=False, bartlett_confint=False, acf_kwargs=None)`\n",
        "\n",
        "|매개변수|설명|기본값|\n",
        "|-----|-----|:-----:|\n",
        "|variable|진단 그림을 만들어야 하는 내인성 변수의 인덱스|0|\n",
        "|lags|상관 도표에 포함할 시차 수|10|\n",
        "|fig|지정된 경우 하위 플롯은 새 그림 대신 이 그림에 작성<br> 2x2 그리드는 fig.add_subplot()를 사용하여 제공된 그림에 생성||\n",
        "|figsize|그림이 작성되면 이 인수를 통해 크기를 지정 >> (너비, 높이)||\n",
        "|auto_ylims|True이면 Y축 한계를 ACF 값으로 자동 조정||\n",
        "|bartlett_confint|ACF 값에 대한 신뢰 구간은 일반적으로 r_k 주위에 2개의 표준 오차가 있음<br>표준 오차에 사용되는 공식은 상황에 따라 다름<br>자기 상관을 사용하여 ARIMA 과정의 일부로 잔차의 랜덤성을 검정하는 경우 잔차가 백색소음이라고 가정하여 표준 오차가 결정||\n",
        "|acf_kwargs|flot_acf()에서 생성된 상관 관계 Matplotlib 플롯에 직접 전달되는 키워드 인수의 선택적 사전||\n",
        "\n",
        "\n",
        "\n",
        "* Standardized residual, Correlogram - 잔차가 백색소음을 따르는지 보여줌\n",
        "  - Standardized residual : 잔차를 시계열로 그린 것\n",
        "  - Correlogram은 잔차에 대한 ACF\n",
        "\n",
        "* Histogram plus estimated density, Normal Q-Q - 잔차가 정규성을 만족하는지 보여줌\n",
        "  - Histogram plus estimated density는 잔차의 히스토그램을 그려 정규 분포 N(0,1)과 밀도를 추정한 그래프를 같이 겹쳐서 보여줌\n",
        "  - Normal Q-Q그래프는 Q-Q 플랏으로 정규성을 만족한다면 빨간 일직선 위에 점들이 분포\n"
      ],
      "metadata": {
        "id": "OVnfcNZOYObs"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H-TlRbrd56pa"
      },
      "outputs": [],
      "source": [
        "arima_result.plot_diagnostics(figsize=(15, 10))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vGg0F49m56pa"
      },
      "outputs": [],
      "source": [
        "# 예측 세트 갯수\n",
        "test.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qcAXeiPS56pa"
      },
      "outputs": [],
      "source": [
        "# 예측 세트 인덱스 시작, 끝 번호 구하기\n",
        "start_no = split_count\n",
        "end_no = split_count + test.shape[0] - 1\n",
        "start_no, end_no"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ggWqvmdr56pa"
      },
      "outputs": [],
      "source": [
        "# 예측\n",
        "predict_value = arima_result.predict(start=start_no, end=end_no, dynamic=True)\n",
        "predict_value[:5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dUmhGJf556pa"
      },
      "outputs": [],
      "source": [
        "y_hat['ARIMA'] = predict_value\n",
        "y_hat['ARIMA'].head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tlmNhEqv56pa"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(15,5))\n",
        "plt.plot(train['거래수'], label='Train')\n",
        "plt.plot(test['거래수'], label='Test')\n",
        "plt.plot(y_hat['ARIMA'], label='Seasonal ARIMA')\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Aw7CxuLY56pb"
      },
      "outputs": [],
      "source": [
        "# root mean squared error 로 오차를 계산해 본다.\n",
        "rmse[\"ARIMA\"] = np.sqrt(np.square(test['거래수'] - y_hat['ARIMA']).mean())\n",
        "rmse[\"ARIMA\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2_T8Jxf_56pb"
      },
      "outputs": [],
      "source": [
        "rmse"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aUKG414N56pb"
      },
      "source": [
        "## fbprophet\n",
        "* 공식문서 : https://facebook.github.io/prophet/docs/quick_start.html#python-api\n",
        "* https://anaconda.org/conda-forge/fbprophet\n",
        "* `conda install -c conda-forge fbprophet`\n",
        "* pip로 설치한다면 pystan이 설치되어 있어야 함"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B8jqiUT256pb"
      },
      "outputs": [],
      "source": [
        "# !pip install pystan\n",
        "# !pip install fbprophet"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W72JIJbi56pb"
      },
      "outputs": [],
      "source": [
        "from fbprophet import Prophet"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df_p = df[[\"시점\", \"거래수\"]].copy()\n",
        "df_p.columns = [\"ds\", \"y\"]\n",
        "df_p[\"y\"] = np.log(df_p[\"y\"])\n",
        "df_p"
      ],
      "metadata": {
        "id": "4PoM__399LkR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "p_train = df_p[:split_count]\n",
        "p_test = df_p[split_count:]\n",
        "p_train.shape, p_test.shape"
      ],
      "metadata": {
        "id": "gUGcZEhz89Ii"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Prophet에서 조정이 가능한 파라미터\n",
        "\n",
        "- 데이터의 상한 하한의 설정\n",
        "- 변동 포인트의 설정\n",
        "- 계절성의 조정\n",
        "- 특별 이벤트의 추가\n",
        "- 신뢰 구간의 조정"
      ],
      "metadata": {
        "id": "muxfkNRQWDIP"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FO0nVOvh56pb"
      },
      "outputs": [],
      "source": [
        "m = Prophet(seasonality_mode='multiplicative')\n",
        "m.fit(p_train)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test.index"
      ],
      "metadata": {
        "id": "SON-QSOV_bSC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test.shape[0]"
      ],
      "metadata": {
        "id": "5vkobXguAE3K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-gBdvurO56pb"
      },
      "outputs": [],
      "source": [
        "# make_future_dataframe 로 미래 데이터를 만들 수도 있으나 여기에서는 미리 나누어 준 p_test 변수를 사용합니다.\n",
        "# future = m.make_future_dataframe(periods=1, freq=\"MS\")\n",
        "# future.tail()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "Qmbm6XfP56pc"
      },
      "outputs": [],
      "source": [
        "forecast = m.predict(p_test)\n",
        "forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o53s4eLM56pc"
      },
      "outputs": [],
      "source": [
        "df_forecast = forecast[['ds', 'yhat']]\n",
        "df_plt_forecast = df_forecast.set_index('ds')\n",
        "df_plt_forecast.shape"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df_plt_forecast"
      ],
      "metadata": {
        "id": "jLnLFQZW9sQg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W7XMAZzO56pc"
      },
      "outputs": [],
      "source": [
        "plt.figure(figsize=(12,5))\n",
        "plt.plot(np.log(train['거래수']), label='Train')\n",
        "plt.plot(np.log(test['거래수']), label='Test')\n",
        "plt.plot(df_plt_forecast['yhat'], label='fbprophet')\n",
        "plt.legend()\n",
        "plt.title(\"로그 변환 예측값\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(12,5))\n",
        "plt.plot(train['거래수'], label='Train')\n",
        "plt.plot(test['거래수'], label='Test')\n",
        "plt.plot(np.exp(df_plt_forecast['yhat']), label='fbprophet')\n",
        "plt.legend()"
      ],
      "metadata": {
        "id": "7GelM1VyHMPV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QVkGxk0P56pc"
      },
      "outputs": [],
      "source": [
        "fig1 = m.plot(forecast)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GTY2Nt5R56pc"
      },
      "outputs": [],
      "source": [
        "fig2 = m.plot_components(forecast)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "U6okRgPz56pc"
      },
      "outputs": [],
      "source": [
        "# plotly 가 설치되어 있지 않다면 아래의 명령어로 설치가 필요\n",
        "# 아나콘다에 설치 시 : conda install -c plotly plotly \n",
        "from fbprophet.plot import plot_plotly\n",
        "\n",
        "fig = plot_plotly(m, forecast)\n",
        "fig.show(renderer=\"colab\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rgEsHTQj56pc"
      },
      "outputs": [],
      "source": [
        "# 변동 포인트의 설정\n",
        "# 빨간 실선은 Trend를 의미(변경점 자동 감지)\n",
        "from fbprophet.plot import add_changepoints_to_plot\n",
        "fig = m.plot(forecast)\n",
        "a = add_changepoints_to_plot(fig.gca(), m, forecast)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "md_pyn76b_7p"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.6"
    },
    "toc": {
      "base_numbering": 1,
      "nav_menu": {},
      "number_sections": true,
      "sideBar": true,
      "skip_h1_title": false,
      "title_cell": "Table of Contents",
      "title_sidebar": "Contents",
      "toc_cell": false,
      "toc_position": {},
      "toc_section_display": true,
      "toc_window_display": false
    },
    "varInspector": {
      "cols": {
        "lenName": 16,
        "lenType": 16,
        "lenVar": 40
      },
      "kernels_config": {
        "python": {
          "delete_cmd_postfix": "",
          "delete_cmd_prefix": "del ",
          "library": "var_list.py",
          "varRefreshCmd": "print(var_dic_list())"
        },
        "r": {
          "delete_cmd_postfix": ") ",
          "delete_cmd_prefix": "rm(",
          "library": "var_list.r",
          "varRefreshCmd": "cat(var_dic_list()) "
        }
      },
      "types_to_exclude": [
        "module",
        "function",
        "builtin_function_or_method",
        "instance",
        "_Feature"
      ],
      "window_display": false
    },
    "colab": {
      "name": "01-time-series-forecast.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}