ARIMA_Daily_GOOGL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dd461906-760f-493c-82c2-ce19c339e9ad",
   "metadata": {},
   "source": [
    "# Time Series Forecasting with ARIMA model\n",
    "\n",
    "ARIMA is the short name for Auto-Regressive Integrated Moving Average.\n",
    "\n",
    "---\n",
    "## Arguments\n",
    "This variable will affect the results throughout the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bef74086-693b-45ed-848f-5f06240bc008",
   "metadata": {},
   "outputs": [],
   "source": [
    "symbol = 'GOOGL'\n",
    "\n",
    "n_data = 1000 # number of data to analyse (0 for all data)\n",
    "n_test = 250 # number of test data (must be smaller than n_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce5c2612-d73f-438e-aa93-1d9034de3e32",
   "metadata": {},
   "source": [
    "---\n",
    "## 1. Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c27f964-c7f3-4211-87ed-a7da02c3c489",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import timedelta  \n",
    "\n",
    "import pandas as pd\n",
    "from pandas.tseries.offsets import DateOffset\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams.update({'figure.figsize':(16,8)})\n",
    "\n",
    "from statsmodels.tsa.stattools import adfuller, acf\n",
    "from statsmodels.tsa.arima_model import ARIMA\n",
    "from statsmodels.tsa.seasonal import seasonal_decompose\n",
    "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n",
    "\n",
    "from pmdarima import auto_arima\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5147d916-c581-44d6-b46d-2e624af931e2",
   "metadata": {},
   "source": [
    "---\n",
    "## 2. Load Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2afbe7c4-b556-4c3f-8331-540b7d4a5874",
   "metadata": {},
   "outputs": [],
   "source": [
    "csv_path = './daily_{}.csv'.format(symbol)\n",
    "\n",
    "dataset_df = pd.read_csv(csv_path)\n",
    "dataset_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f86a5950-a7cd-408c-8f18-2b59e97dddba",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa4ae2c8-c3d0-4f3f-99b7-80e0ed0fc6c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "349f260c-14d5-43f7-b452-bdc30e38fa6f",
   "metadata": {},
   "source": [
    "---\n",
    "## 3. Data Cleanup & Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71ec1477-7642-4940-91ec-afc841541bc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a clean dataset with only timestamp and close columns\n",
    "data_df = pd.DataFrame(dataset_df[['timestamp', 'close']]) \n",
    "data_df[\"timestamp\"] = pd.to_datetime(data_df[\"timestamp\"]) # convert timestamp to datetime type\n",
    "data_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5b0bf4c-ee05-4b6d-93aa-c8e05c93a29d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# sort the date by ascending order\n",
    "data_df.sort_values(by=\"timestamp\", inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "753f4574-ec1c-4ea9-90a8-544b3a49bb98",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set the timestamp as index\n",
    "data_df.set_index('timestamp', drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8bbac5b-ffeb-45c4-a502-46d297de3a50",
   "metadata": {},
   "outputs": [],
   "source": [
    "# find the date range of the dataset\n",
    "start_dt = data_df.index.min()\n",
    "end_dt = data_df.index.max()\n",
    "dt_idx = pd.date_range(start_dt, end_dt)\n",
    "\n",
    "# fill those empty date with 0\n",
    "data_df = data_df.reindex(dt_idx, fill_value=0)\n",
    "\n",
    "# fill in those missing row value with the available non zero value before it\n",
    "for index, row in data_df.iterrows():\n",
    "    if row['close'] == 0:\n",
    "        prev_index = index - timedelta(days=1)  \n",
    "        row['close'] = data_df.loc[prev_index]['close']\n",
    "        \n",
    "data_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56ba0bd2-c855-4fad-b1a1-58057c3b6a9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get only the last N number of day (N = n_data which is define in the arguments section above)  (0 for all data)\n",
    "if n_data != 0:\n",
    "    start_idx = len(data_df)-min(n_data,len(data_df))\n",
    "    data_df = data_df[start_idx:]\n",
    "data_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0df39f2b-337e-457b-add5-47cb5b76eaee",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b67b1316-8e9d-4429-8fb7-b33d3179c716",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(data_df['close'])\n",
    "plt.xlabel(\"Timestamp\")\n",
    "plt.ylabel(\"Close Price\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f78c45c1-5a10-42d0-b9f9-4f1201f6777e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# split the dataset to Train and Test set\n",
    "train = data_df['close'][:len(data_df)-n_test]\n",
    "test = data_df['close'][len(data_df)-n_test:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3e7c956-6fb4-4aaa-b349-f53e77a72030",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(train)\n",
    "plt.plot(test)\n",
    "plt.xlabel(\"Timestamp\")\n",
    "plt.ylabel(\"Close Price\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3817bb8-061a-492d-b01b-fe54f3bcd355",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5baa1919-ef01-436c-bdb0-3bf92ff445cf",
   "metadata": {},
   "source": [
    "## 4. Stationary Check\n",
    "\n",
    "ARIMA model require the time series to be stationary.  \n",
    "For the time series to be stationary, it's\n",
    "+ Mean must be constant\n",
    "+ Variance must be constant\n",
    "+ There are no seasonality"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d98eb93-d434-4d38-b2be-afa9d6dc58d8",
   "metadata": {},
   "source": [
    "### 4.1 Visualizing the Time Series Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bce0510f-7340-42a1-9aaf-78d10992c992",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(train)\n",
    "plt.xlabel(\"Timestamp\")\n",
    "plt.ylabel(\"Close Price\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df118b26-578a-4340-9957-ae48f36f9dee",
   "metadata": {},
   "source": [
    "From the plot above, the mean is not constant throughout time. Therefore, the time series is not stationary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30723ce1-b7c0-42c6-842d-52c902063c5e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2296e183-56da-4f9a-98d7-67d38a6721a4",
   "metadata": {},
   "source": [
    "### 4.2 Augmented Dickey-Fuller (ADF)\n",
    "Check if the time series is stationary using Augmented Dickey-Fuller (ADF) test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ce27ffa-893d-4eb5-85a9-c0308d2bbcab",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Ho: It is non stationary\n",
    "#H1: It is stationary\n",
    "\n",
    "def adfuller_test(data):\n",
    "    result=adfuller(data)\n",
    "    labels = ['ADF Test Statistic','p-value','#Lags Used','Number of Observations Used']\n",
    "    for value,label in zip(result,labels):\n",
    "        print(label+' : '+str(value) )\n",
    "    if result[1] <= 0.05:\n",
    "        print(\"strong evidence against the null hypothesis(Ho), reject the null hypothesis. Data has no unit root and is stationary\")\n",
    "    else:\n",
    "        print(\"weak evidence against null hypothesis, time series has a unit root, indicating it is non-stationary \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a8fe38c-995c-4161-a504-943eaf3b4a1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "adfuller_test(train.dropna())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "181fb044-44a6-4c9a-b4e2-701b6741c91f",
   "metadata": {},
   "source": [
    "From the above ADF result, we can see that the time series is not stationary as the p-value is way more than the threshold value or significance level of 0.05."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82e8213f-16cd-487b-9b3a-c9fb049a11d6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d26d11d7-8e48-4256-a200-95bb3a3523c7",
   "metadata": {},
   "source": [
    "---\n",
    "## 5. Find ARIMA model Parameters\n",
    "\n",
    "ARIMA model require 3 parameters p, d, & q where,\n",
    "\n",
    "+ p is the order of the Auto Regressive (AR) term which is the number of lags of Y to be used as predictors\n",
    "+ q is the order of the Moving Average (MA) term which is the number of lagged forecast errors\n",
    "+ d is the number of differencing required to make the time series stationary\n",
    "\n",
    "Below are 2 methods we could use to find the parameters:\n",
    "+ ACF and PACF plots method\n",
    "+ AUTO_ARIMA function\n",
    "\n",
    "### 5.1. Finding Parameters using ACF and PACF plot methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0ef19cd-06d0-4067-ab33-e831c473abfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(18,12))\n",
    "\n",
    "ax1 = fig.add_subplot(331)\n",
    "ax1.set_title('Original Series')\n",
    "ax1.plot(train)\n",
    "\n",
    "ax2 = fig.add_subplot(334)\n",
    "plot_acf(train, ax=ax2)\n",
    "\n",
    "ax3 = fig.add_subplot(337)\n",
    "plot_pacf(train, ax=ax3)\n",
    "\n",
    "ax4 = fig.add_subplot(332)\n",
    "ax4.set_title('1st Order Differencing')\n",
    "ax4.plot(train.diff().dropna())\n",
    "\n",
    "ax5 = fig.add_subplot(335)\n",
    "plot_acf(train.diff().dropna(), ax=ax5)\n",
    "\n",
    "ax6 = fig.add_subplot(338)\n",
    "plot_pacf(train, ax=ax6)\n",
    "\n",
    "ax7 = fig.add_subplot(333)\n",
    "ax7.set_title('2nd Order Differencing')\n",
    "ax7.plot(train.diff().diff().dropna())\n",
    "\n",
    "ax8 = fig.add_subplot(336)\n",
    "plot_acf(train.diff().diff().dropna(), ax=ax8)\n",
    "\n",
    "ax9 = fig.add_subplot(339)\n",
    "plot_pacf(train, ax=ax9)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a610364-1141-44d6-b273-74fa67689763",
   "metadata": {},
   "source": [
    "Looking at the 1st row plot, we will select d = 1.  \n",
    "Looking at the selected d column 2nd row plot, we will select q = 0 based on MA term.  \n",
    "Looking at the selected d column 3rd row plot, we will select p = 1 based on AR term."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b32a9465-0ba8-481a-b110-02ec54a35120",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6369db22-97e7-4658-bd95-4be5e45b420e",
   "metadata": {},
   "source": [
    "### 5.2. Finding Parameters using AUTO_ARIMA function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c27755cf-f3b9-4331-bf8d-0d8e198501ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "auto_arima(train, trace=True, error_action='ignore', suppress_warnings=True, stepwise=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0179dc0e-e690-462e-b4e5-6c9dee8469bd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9cd1e5e1-293f-4b6f-8104-678d03f198ec",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## 6. Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b522c63-5c97-46a6-95b0-a5bb7857d19e",
   "metadata": {},
   "outputs": [],
   "source": [
    "arima_order = (1, 1, 0) # p, d, q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c36df03-e57e-45d8-abc7-1d18f517b685",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create and fit model\n",
    "model = ARIMA(train, order=arima_order) \n",
    "#modelfit = model.fit(disp = 0)\n",
    "model_fit = model.fit()\n",
    "model_fit.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9a6b156-3ebf-4a15-975b-e6f8a1e8c71c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# show Actual vs Fitted plot\n",
    "model_fit.plot_predict(dynamic=False)  \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43139523-4678-4876-837f-b7876525fc6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot residual errors\n",
    "residuals = pd.DataFrame(model_fit.resid)\n",
    "fig, ax = plt.subplots(2,1)\n",
    "residuals.plot(title=\"Residuals\", ax=ax[0])\n",
    "residuals.plot(kind='kde', title='Density', ax=ax[1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "262d6c0e-e503-4faa-9eb4-772997d1d602",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2f0c740d-9f8f-4bd9-9629-1b69b46fe4b2",
   "metadata": {},
   "source": [
    "---\n",
    "## 7. Forecast Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2d39d9a-eddd-4916-b5ca-00852ca29fb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Forecast\n",
    "fc, se, conf = model_fit.forecast(n_test, alpha=0.05)  # 95% conf\n",
    "\n",
    "# Make as pandas series\n",
    "fc_series = pd.Series(fc, index=test.index)\n",
    "lower_series = pd.Series(conf[:, 0], index=test.index)\n",
    "upper_series = pd.Series(conf[:, 1], index=test.index)\n",
    "\n",
    "# Plot\n",
    "plt.figure(figsize=(12,5), dpi=100)\n",
    "plt.plot(train, label='training')\n",
    "plt.plot(test, label='actual')\n",
    "plt.plot(fc_series, label='forecast')\n",
    "plt.fill_between(lower_series.index, lower_series, upper_series, \n",
    "                 color='k', alpha=.15)\n",
    "plt.title('Forecast vs Actuals')\n",
    "plt.legend(loc='upper left', fontsize=8)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfedce2d-3e15-47ef-9225-8f41e9a930bb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a5532994-fb7e-4446-8333-00061e63ee24",
   "metadata": {},
   "source": [
    "---\n",
    "## 8. Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08f606c3-a18b-4516-8229-9879377027a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accuracy metrics\n",
    "def forecast_accuracy(forecast, actual):\n",
    "    mape = np.mean(np.abs(forecast - actual)/np.abs(actual))  # MAPE\n",
    "    me = np.mean(forecast - actual)             # ME\n",
    "    mae = np.mean(np.abs(forecast - actual))    # MAE\n",
    "    mpe = np.mean((forecast - actual)/actual)   # MPE\n",
    "    rmse = np.mean((forecast - actual)**2)**.5  # RMSE\n",
    "    corr = np.corrcoef(forecast, actual)[0,1]   # corr\n",
    "    mins = np.amin(np.hstack([forecast[:,None], \n",
    "                              actual[:,None]]), axis=1)\n",
    "    maxs = np.amax(np.hstack([forecast[:,None], \n",
    "                              actual[:,None]]), axis=1)\n",
    "    minmax = 1 - np.mean(mins/maxs)             # minmax\n",
    "    acf1 = acf(fc-test)[1]                      # ACF1\n",
    "    return({'mape':mape, 'me':me, 'mae': mae, \n",
    "            'mpe': mpe, 'rmse':rmse, 'acf1':acf1, \n",
    "            'corr':corr, 'minmax':minmax})\n",
    "\n",
    "forecast_accuracy(fc, test.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b95042ca-8b28-43f1-a8eb-5d434f9a586a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}