建模算法/预测/整合移动平均自回归(ARIMA)/ARIMA.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "277307eb-05a6-49c2-bd9a-06116396008c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set(style=\"whitegrid\")\n",
    "import statsmodels.api as sm\n",
    "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n",
    "from statsmodels.stats.diagnostic import acorr_ljungbox  # 白噪声检验\n",
    "import statsmodels.tsa.stattools as st\n",
    "import scipy.stats as scs\n",
    "from statsmodels.tsa.arima_model import ARIMA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6f932ce1-f76e-4833-89fd-91cb27020f16",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Arima:\n",
    "    def __init__(self, data, n):\n",
    "        \"\"\"\n",
    "            :param data: Series/np/list\n",
    "            :param n: 预测数量\n",
    "        \"\"\"\n",
    "        plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "        plt.rcParams['axes.unicode_minus'] = False\n",
    "        if isinstance(data, pd.Series):\n",
    "            self.data = data.values\n",
    "        elif isinstance(data, np.ndarray):\n",
    "            self.data = data\n",
    "        elif isinstance(data, list):\n",
    "            self.data = np.array(data)\n",
    "        self.check()\n",
    "        self.pre_model()\n",
    "        self.build_model(n)\n",
    "        print(\"返回值为dataframe，可通过.res_df拿到, 可通过.plot_res画预测图\\n\", self.res_df)\n",
    "\n",
    "    def check(self):\n",
    "        series = pd.Series(self.data.reshape(-1))\n",
    "        # 平稳性ADF检验\n",
    "        print('+++++++++++++++++++++++++++++++++开始进行平稳性ADF检验+++++++++++++++++++++++++++++++')\n",
    "        d = 0\n",
    "        while (True):\n",
    "            if (d > 0):\n",
    "                series = series.diff(1)\n",
    "                series = series.dropna(how=any)\n",
    "            t = sm.tsa.stattools.adfuller(series, )\n",
    "            output = pd.DataFrame(\n",
    "                index=['Test Statistic Value', \"p-value\", \"Lags Used\", \"Number of Observations Used\",\n",
    "                       \"Critical Value(1%)\",\n",
    "                       \"Critical Value(5%)\", \"Critical Value(10%)\"], columns=['value'])\n",
    "            output['value']['Test Statistic Value'] = t[0]\n",
    "            output['value']['p-value'] = t[1]\n",
    "            output['value']['Lags Used'] = t[2]\n",
    "            output['value']['Number of Observations Used'] = t[3]\n",
    "            output['value']['Critical Value(1%)'] = t[4]['1%']\n",
    "            output['value']['Critical Value(5%)'] = t[4]['5%']\n",
    "            output['value']['Critical Value(10%)'] = t[4]['10%']\n",
    "            print(output)\n",
    "            if t[1] > 0.05:\n",
    "                print(f'单位根检验中p值为{t[1]}，大于0.05，为非平稳序列,进行{d + 1}阶差分')\n",
    "                d += 1\n",
    "            else:\n",
    "                print('单位根检验中p值为%.2f，小于0.05，为平稳序列' % (t[1]))\n",
    "                self.d = d\n",
    "                break\n",
    "        print(f'++++++++++++++++++++++++++ADF检验完成，{d}阶差分后已为平稳序列+++++++++++++++++++++++++++++++')\n",
    "        print(f'++++++++++++++++++++++++++开始白噪声检验+++++++++++++++++++++++++++++++')\n",
    "        noiseP = acorr_ljungbox(series, lags=1)[-1]\n",
    "        if noiseP <= 0.05:\n",
    "            print('白噪声检验中p值为%.2f，小于0.05，为非白噪声' % noiseP)\n",
    "        else:\n",
    "            print('白噪声检验中%.2f，大于0.05，为白噪声' % noiseP)\n",
    "        print(f'++++++++++++++++++++++++++白噪声检验完成+++++++++++++++++++++++++++++++')\n",
    "        self.data_diff = series\n",
    "\n",
    "    def pre_model(self):\n",
    "        series = self.data_diff\n",
    "        self.time_plot(series)\n",
    "        import warnings\n",
    "        warnings.filterwarnings(\"ignore\")\n",
    "        pMax = int(series.shape[0] / 10)  # 一般阶数不超过length/10\n",
    "        qMax = pMax  # 一般阶数不超过length/10\n",
    "        order = st.arma_order_select_ic(series, max_ar=pMax, max_ma=qMax, ic=['aic', 'bic', 'hqic'])\n",
    "        p, q = order.aic_min_order\n",
    "        print('AIC准则下确定p,q为%s,%s' % (p, q))\n",
    "        p, q = order.bic_min_order\n",
    "        print('BIC准则下确定p,q为%s,%s' % (p, q))\n",
    "        self.q = q\n",
    "        self.p = p\n",
    "\n",
    "    # 借助AIC、BIC统计量自动确定p,q\n",
    "    def build_model(self, n):\n",
    "        print(f'++++++++++++++++++++++++++开始建立ARIMA模型+++++++++++++++++++++++++++++++')\n",
    "        series = pd.Series(self.data.reshape(-1))\n",
    "        print('ARIMA建模使用参数：p=%s,d=%s,q=%s' % (self.p, self.d, self.q))\n",
    "        model = ARIMA(series, order=(self.p, self.d, self.q)).fit()\n",
    "        predict_n = model.forecast(n)[0]\n",
    "        print(model.summary())\n",
    "\n",
    "        fit_v = model.fittedvalues\n",
    "        for _ in range(self.d):\n",
    "            fit_v = fit_v.cumsum()\n",
    "        fit_v += series[0]\n",
    "        fit_res = [series[0]]\n",
    "        fit_res.extend(x for x in fit_v)\n",
    "        fit_res.extend(x for x in predict_n)\n",
    "\n",
    "        delta = [np.nan]\n",
    "        delta.extend(x for x in model.resid)\n",
    "        self.res_df = pd.concat([pd.DataFrame({'原始值': self.data}), pd.DataFrame({'预测值': fit_res}),\n",
    "                                 pd.DataFrame({'残差': delta}),\n",
    "                                 pd.DataFrame({'相对误差': list(map(lambda x: '{:.2%}'.format(x), np.abs(delta / self.data)))})\n",
    "                                 ], axis=1)\n",
    "        self.verify(model.resid)\n",
    "\n",
    "    # 模型验证，针对残差\n",
    "    def verify(self, resid):\n",
    "        print(f'++++++++++++++++++++++++++开始模型验证+++++++++++++++++++++++++++++++')\n",
    "        t = sm.tsa.stattools.adfuller(resid, )\n",
    "        output = pd.DataFrame(\n",
    "            index=['Test Statistic Value', \"p-value\", \"Lags Used\", \"Number of Observations Used\",\n",
    "                   \"Critical Value(1%)\",\n",
    "                   \"Critical Value(5%)\", \"Critical Value(10%)\"], columns=['value'])\n",
    "        output['value']['Test Statistic Value'] = t[0]\n",
    "        output['value']['p-value'] = t[1]\n",
    "        output['value']['Lags Used'] = t[2]\n",
    "        output['value']['Number of Observations Used'] = t[3]\n",
    "        output['value']['Critical Value(1%)'] = t[4]['1%']\n",
    "        output['value']['Critical Value(5%)'] = t[4]['5%']\n",
    "        output['value']['Critical Value(10%)'] = t[4]['10%']\n",
    "        print(output)\n",
    "        resid = pd.Series(resid)\n",
    "        self.time_plot(resid, title='ARIMA残差')\n",
    "\n",
    "    def time_plot(self, series, title=''):\n",
    "        plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "        fig = plt.figure(figsize=(10, 8))\n",
    "        layout = (3, 2)\n",
    "        ts_ax = plt.subplot2grid(layout, (0, 0), colspan=2)\n",
    "        acf_ax = plt.subplot2grid(layout, (1, 0))\n",
    "        pacf_ax = plt.subplot2grid(layout, (1, 1))\n",
    "        qq_ax = plt.subplot2grid(layout, (2, 0))\n",
    "        pp_ax = plt.subplot2grid(layout, (2, 1))\n",
    "        series.plot(ax=ts_ax)\n",
    "        ts_ax.set_title(f'{title}时序图')\n",
    "        plot_acf(series, ax=acf_ax, alpha=0.5)\n",
    "        acf_ax.set_title('自相关系数')\n",
    "#         plot_pacf(series.values, ax=pacf_ax, nlags=series.shape[0]-2,alpha=0.5)\n",
    "        pacf_ax.set_title('偏自相关系数')\n",
    "        sm.qqplot(series, line='s', ax=qq_ax)\n",
    "        qq_ax.set_title('QQ 图')\n",
    "        scs.probplot(series, sparams=(series.mean(),\n",
    "                                      series.std()), plot=pp_ax)\n",
    "        pp_ax.set_title('PP 图')\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    def plot_res(self, xlabel='', ylabel=''):\n",
    "        res_df = self.res_df\n",
    "        f, ax = plt.subplots(figsize=(8, 5))\n",
    "        sns.lineplot(x=res_df.index.tolist(), y=res_df['预测值'], linewidth=2, ax=ax)\n",
    "        sns.scatterplot(x=res_df.index.tolist(), y=res_df['原始值'], s=60, color='r', marker='v', ax=ax)\n",
    "        plt.fill_between(np.where(np.isnan(res_df[\"原始值\"]))[0], y1=min(plt.yticks()[0]), y2=max(plt.yticks()[0]),\n",
    "                         color='orange', alpha=0.2)\n",
    "        ax.set_xlabel(xlabel, fontsize=15)\n",
    "        ax.set_ylabel(ylabel, fontsize=15)\n",
    "        plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f675fcbe-ee5d-4a1e-8916-0041e052b210",
   "metadata": {},
   "source": [
    "偏自相关性图注释掉了，有bug还是怎么地 画不出来"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6feb60ad-dd7c-43b8-b961-3bcc344b154c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df=pd.read_csv(r'../ym_num.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a4ebed68-4412-479f-8294-409028ba31ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>y-m</th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2015-1</td>\n",
       "      <td>4012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2015-2</td>\n",
       "      <td>3761</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2015-3</td>\n",
       "      <td>3660</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2015-4</td>\n",
       "      <td>3532</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2016-1</td>\n",
       "      <td>3460</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2016-2</td>\n",
       "      <td>3629</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>2016-3</td>\n",
       "      <td>3321</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>2016-4</td>\n",
       "      <td>3177</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>2017-1</td>\n",
       "      <td>2719</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>2017-2</td>\n",
       "      <td>3023</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>2017-3</td>\n",
       "      <td>2800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>2017-4</td>\n",
       "      <td>2358</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       y-m     0\n",
       "0   2015-1  4012\n",
       "1   2015-2  3761\n",
       "2   2015-3  3660\n",
       "3   2015-4  3532\n",
       "4   2016-1  3460\n",
       "5   2016-2  3629\n",
       "6   2016-3  3321\n",
       "7   2016-4  3177\n",
       "8   2017-1  2719\n",
       "9   2017-2  3023\n",
       "10  2017-3  2800\n",
       "11  2017-4  2358"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d7191bec-e3a5-44ad-accf-51b54587afa7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+++++++++++++++++++++++++++++++++开始进行平稳性ADF检验+++++++++++++++++++++++++++++++\n",
      "                               value\n",
      "Test Statistic Value          3.7166\n",
      "p-value                            1\n",
      "Lags Used                          4\n",
      "Number of Observations Used        7\n",
      "Critical Value(1%)          -4.93869\n",
      "Critical Value(5%)          -3.47758\n",
      "Critical Value(10%)         -2.84387\n",
      "单位根检验中p值为1.0，大于0.05，为非平稳序列,进行1阶差分\n",
      "                                value\n",
      "Test Statistic Value         -3.98249\n",
      "p-value                      0.001505\n",
      "Lags Used                           0\n",
      "Number of Observations Used        10\n",
      "Critical Value(1%)           -4.33157\n",
      "Critical Value(5%)           -3.23295\n",
      "Critical Value(10%)           -2.7487\n",
      "单位根检验中p值为0.00，小于0.05，为平稳序列\n",
      "++++++++++++++++++++++++++ADF检验完成，1阶差分后已为平稳序列+++++++++++++++++++++++++++++++\n",
      "++++++++++++++++++++++++++开始白噪声检验+++++++++++++++++++++++++++++++\n",
      "白噪声检验中0.20，大于0.05，为白噪声\n",
      "++++++++++++++++++++++++++白噪声检验完成+++++++++++++++++++++++++++++++\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\ANACONDA\\envs\\mathmodel\\lib\\site-packages\\statsmodels\\stats\\diagnostic.py:559: FutureWarning: The value returned will change to a single DataFrame after 0.12 is released.  Set return_df to True to use to return a DataFrame now.  Set return_df to False to silence this warning.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AIC准则下确定p,q为0,1\n",
      "BIC准则下确定p,q为0,1\n",
      "++++++++++++++++++++++++++开始建立ARIMA模型+++++++++++++++++++++++++++++++\n",
      "ARIMA建模使用参数：p=0,d=1,q=1\n",
      "                             ARIMA Model Results                              \n",
      "==============================================================================\n",
      "Dep. Variable:                    D.y   No. Observations:                   11\n",
      "Model:                 ARIMA(0, 1, 1)   Log Likelihood                   3.540\n",
      "Method:                       css-mle   S.D. of innovations              0.157\n",
      "Date:                Fri, 09 Jul 2021   AIC                             -1.080\n",
      "Time:                        14:23:06   BIC                              0.114\n",
      "Sample:                             1   HQIC                            -1.832\n",
      "                                                                              \n",
      "==============================================================================\n",
      "                 coef    std err          z      P>|z|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "const         -0.1277      0.013     -9.748      0.000      -0.153      -0.102\n",
      "ma.L1.D.y     -1.0000      0.283     -3.539      0.000      -1.554      -0.446\n",
      "                                    Roots                                    \n",
      "=============================================================================\n",
      "                  Real          Imaginary           Modulus         Frequency\n",
      "-----------------------------------------------------------------------------\n",
      "MA.1            1.0000           +0.0000j            1.0000            0.0000\n",
      "-----------------------------------------------------------------------------\n",
      "++++++++++++++++++++++++++开始模型验证+++++++++++++++++++++++++++++++\n",
      "                                 value\n",
      "Test Statistic Value          -2.86265\n",
      "p-value                      0.0498672\n",
      "Lags Used                            0\n",
      "Number of Observations Used         10\n",
      "Critical Value(1%)            -4.33157\n",
      "Critical Value(5%)            -3.23295\n",
      "Critical Value(10%)            -2.7487\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "返回值为dataframe，可通过.res_df拿到, 可通过.plot_res画预测图\n",
      "       原始值       预测值        残差    相对误差\n",
      "0   4.012  4.012000       NaN    nan%\n",
      "1   3.761  3.884294 -0.123294   3.28%\n",
      "2   3.660  3.818234 -0.034941   0.95%\n",
      "3   3.532  3.713822 -0.023587   0.67%\n",
      "4   3.460  3.603806  0.038016   1.10%\n",
      "5   3.629  3.445687  0.327119   9.01%\n",
      "6   3.321  3.045382  0.092305   2.78%\n",
      "7   3.177  2.838556  0.062825   1.98%\n",
      "8   2.719  2.655878 -0.275322  10.13%\n",
      "9   3.023  2.772902  0.186976   6.19%\n",
      "10  2.800  2.476918  0.072985   2.61%\n",
      "11  2.358  2.282862 -0.247944  10.52%\n",
      "12    NaN  2.478238       NaN     NaN\n",
      "13    NaN  2.350531       NaN     NaN\n",
      "14    NaN  2.222825       NaN     NaN\n",
      "15    NaN  2.095119       NaN     NaN\n",
      "16    NaN  1.967413       NaN     NaN\n",
      "17    NaN  1.839706       NaN     NaN\n",
      "18    NaN  1.712000       NaN     NaN\n",
      "19    NaN  1.584294       NaN     NaN\n",
      "20    NaN  1.456587       NaN     NaN\n",
      "21    NaN  1.328881       NaN     NaN\n"
     ]
    }
   ],
   "source": [
    "arima=Arima(df['0']/1000,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "38c5ab7d-1839-4eb6-9e7b-067e04262f34",
   "metadata": {},
   "outputs": [],
   "source": [
    "res_df=arima.res_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f5a97091-3909-4bc1-a7c7-5077c211c607",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>原始值</th>\n",
       "      <th>预测值</th>\n",
       "      <th>残差</th>\n",
       "      <th>相对误差</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4.012</td>\n",
       "      <td>4.012000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>nan%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3.761</td>\n",
       "      <td>3.884294</td>\n",
       "      <td>-0.123294</td>\n",
       "      <td>3.28%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.660</td>\n",
       "      <td>3.818234</td>\n",
       "      <td>-0.034941</td>\n",
       "      <td>0.95%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3.532</td>\n",
       "      <td>3.713822</td>\n",
       "      <td>-0.023587</td>\n",
       "      <td>0.67%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.460</td>\n",
       "      <td>3.603806</td>\n",
       "      <td>0.038016</td>\n",
       "      <td>1.10%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>3.629</td>\n",
       "      <td>3.445687</td>\n",
       "      <td>0.327119</td>\n",
       "      <td>9.01%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>3.321</td>\n",
       "      <td>3.045382</td>\n",
       "      <td>0.092305</td>\n",
       "      <td>2.78%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>3.177</td>\n",
       "      <td>2.838556</td>\n",
       "      <td>0.062825</td>\n",
       "      <td>1.98%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>2.719</td>\n",
       "      <td>2.655878</td>\n",
       "      <td>-0.275322</td>\n",
       "      <td>10.13%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>3.023</td>\n",
       "      <td>2.772902</td>\n",
       "      <td>0.186976</td>\n",
       "      <td>6.19%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>2.800</td>\n",
       "      <td>2.476918</td>\n",
       "      <td>0.072985</td>\n",
       "      <td>2.61%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>2.358</td>\n",
       "      <td>2.282862</td>\n",
       "      <td>-0.247944</td>\n",
       "      <td>10.52%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>NaN</td>\n",
       "      <td>2.478238</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>NaN</td>\n",
       "      <td>2.350531</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>NaN</td>\n",
       "      <td>2.222825</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>NaN</td>\n",
       "      <td>2.095119</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.967413</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.839706</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.712000</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.584294</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.456587</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.328881</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      原始值       预测值        残差    相对误差\n",
       "0   4.012  4.012000       NaN    nan%\n",
       "1   3.761  3.884294 -0.123294   3.28%\n",
       "2   3.660  3.818234 -0.034941   0.95%\n",
       "3   3.532  3.713822 -0.023587   0.67%\n",
       "4   3.460  3.603806  0.038016   1.10%\n",
       "5   3.629  3.445687  0.327119   9.01%\n",
       "6   3.321  3.045382  0.092305   2.78%\n",
       "7   3.177  2.838556  0.062825   1.98%\n",
       "8   2.719  2.655878 -0.275322  10.13%\n",
       "9   3.023  2.772902  0.186976   6.19%\n",
       "10  2.800  2.476918  0.072985   2.61%\n",
       "11  2.358  2.282862 -0.247944  10.52%\n",
       "12    NaN  2.478238       NaN     NaN\n",
       "13    NaN  2.350531       NaN     NaN\n",
       "14    NaN  2.222825       NaN     NaN\n",
       "15    NaN  2.095119       NaN     NaN\n",
       "16    NaN  1.967413       NaN     NaN\n",
       "17    NaN  1.839706       NaN     NaN\n",
       "18    NaN  1.712000       NaN     NaN\n",
       "19    NaN  1.584294       NaN     NaN\n",
       "20    NaN  1.456587       NaN     NaN\n",
       "21    NaN  1.328881       NaN     NaN"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "facb4193-6da5-40cf-9322-afa9aa8ecb4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "arima.plot_res(xlabel=\"2015-2017季度\",ylabel=\"案件数量\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "eee14534-c240-4ef9-9e6f-c97784d81c44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ARIMA预测 {'mse': 0.041221102782066664, 'RMSE': 0.20302980761963663}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error\n",
    "mse = mean_squared_error(res_df['原始值'][:12], res_df['预测值'][:12])\n",
    "print(\"ARIMA预测\",{\"mse\": mse,'RMSE':np.sqrt(mse)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "27ecea8d-3b3a-47f5-8a80-395429eb21c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=arima.data_diff\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4d0e2f6f-14db-4ba0-8bb6-002b21941bcc",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Can only compute partial correlations for lags up to 50% of the sample size. The requested nlags 10 must be < 5.",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-25-672469156f8e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mplot_pacf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mE:\\ANACONDA\\envs\\mathmodel\\lib\\site-packages\\statsmodels\\graphics\\tsaplots.py\u001b[0m in \u001b[0;36mplot_pacf\u001b[1;34m(x, ax, lags, alpha, method, use_vlines, title, zero, vlines_kwargs, **kwargs)\u001b[0m\n\u001b[0;32m    305\u001b[0m         \u001b[0macf_x\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpacf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnlags\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnlags\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    306\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 307\u001b[1;33m         \u001b[0macf_x\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mconfint\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpacf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnlags\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnlags\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0malpha\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    308\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    309\u001b[0m     _plot_corr(\n",
      "\u001b[1;32mE:\\ANACONDA\\envs\\mathmodel\\lib\\site-packages\\statsmodels\\tsa\\stattools.py\u001b[0m in \u001b[0;36mpacf\u001b[1;34m(x, nlags, method, alpha)\u001b[0m\n\u001b[0;32m   1032\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mnlags\u001b[0m \u001b[1;33m>=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m//\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1033\u001b[0m         raise ValueError(\n\u001b[1;32m-> 1034\u001b[1;33m             \u001b[1;34m\"Can only compute partial correlations for lags up to 50% of the \"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1035\u001b[0m             \u001b[1;34mf\"sample size. The requested nlags {nlags} must be < \"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1036\u001b[0m             \u001b[1;34mf\"{x.shape[0] // 2}.\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Can only compute partial correlations for lags up to 50% of the sample size. The requested nlags 10 must be < 5."
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_pacf(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef779eef-5b91-423f-bc7e-720a1e8addf1",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}