Time_Series_Forecasting_With_MLPs.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MLPs For Univaraite Forecasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "#imports\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"data/Alcohol_Sales.csv\", infer_datetime_format=True, index_col='DATE')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['S4248SM144NCEN'], dtype='object')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.rename({\"S4248SM144NCEN\":\"Sales\"}, inplace=True, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Sales'], dtype='object')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Sales'], dtype='object')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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>Sales</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DATE</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1992-01-01</th>\n",
       "      <td>3459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-02-01</th>\n",
       "      <td>3458</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-03-01</th>\n",
       "      <td>4002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-04-01</th>\n",
       "      <td>4564</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1992-05-01</th>\n",
       "      <td>4221</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Sales\n",
       "DATE             \n",
       "1992-01-01   3459\n",
       "1992-02-01   3458\n",
       "1992-03-01   4002\n",
       "1992-04-01   4564\n",
       "1992-05-01   4221"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sales    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(325, 1)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hyperparameters:\n",
    "\n",
    "- `n_input`: The number of lag observations to use as input to the model.\n",
    "- `n_nodes`: The number of nodes to use in the hidden layer.\n",
    "- `n_epochs`: The number of times to expose the model to the whole training dataset.\n",
    "- `n_batch`: The number of samples within an epoch after which the weights are updated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hyperparameters\n",
    "n_input = 12\n",
    "n_nodes = 100\n",
    "n_epochs = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "325 - 16*19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# split a univariate dataset into train/test sets\n",
    "def train_test_split(data, n_test):\n",
    "  return data[:-n_test], data[-n_test:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3459.,  3458.,  4002., ...,  4240.,  4936.,  3031.],\n",
       "       [ 3458.,  4002.,  4564., ...,  4936.,  3031.,  3261.],\n",
       "       [ 4002.,  4564.,  4221., ...,  3031.,  3261.,  4160.],\n",
       "       ...,\n",
       "       [13261., 14265.,  9564., ..., 12396., 13914., 14174.],\n",
       "       [14265.,  9564., 10415., ..., 13914., 14174., 15504.],\n",
       "       [ 9564., 10415., 12683., ..., 14174., 15504., 10718.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# transform list into supervised learning format\n",
    "def series_to_supervised(data, n_in, n_out=1):\n",
    "  df = pd.DataFrame(data)\n",
    "  cols = list()\n",
    "  # input sequence (t-n, ... t-1)\n",
    "  for i in range(n_in, 0, -1):\n",
    "    cols.append(df.shift(i))\n",
    "  # forecast sequence (t, t+1, ... t+n)\n",
    "  for i in range(0, n_out):\n",
    "    cols.append(df.shift(-i))\n",
    "  # put it all together\n",
    "  agg = pd.concat(cols, axis=1)\n",
    "  # drop rows with NaN values\n",
    "  agg.dropna(inplace=True)\n",
    "  \n",
    "  return agg.values\n",
    "\n",
    "series_to_supervised(df.values, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train shape : (304, 1), test shape : (21, 1)\n"
     ]
    }
   ],
   "source": [
    "train, test = train_test_split(df, 21)\n",
    "\n",
    "print(f\"train shape : {train.shape}, test shape : {test.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((292, 12), (292,))"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = series_to_supervised(train, n_input)\n",
    "train_x, train_y = data[:, :-1], data[:, -1]\n",
    "train_x.shape, train_y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3504"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_x.shape[0] * train_x.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(292, 12)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define model\n",
    "\n",
    "class TimeSeriesMLPModel(nn.Module):\n",
    "\n",
    "    def __init__(self, n_input, n_nodes) -> None:\n",
    "        super().__init__()\n",
    "        self.lm_linear = nn.Sequential(\n",
    "            nn.Linear(in_features=n_input, out_features=n_nodes),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(in_features=n_nodes, out_features=1),\n",
    "            )\n",
    "    def forward(self, X):\n",
    "        \n",
    "        B, T = X.shape\n",
    "        logits = self.lm_linear(X)\n",
    "        return logits\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_input = 12\n",
    "n_nodes = 100\n",
    "mlp_model  = TimeSeriesMLPModel(n_input, n_nodes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "#loss function and optimizer\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(mlp_model.parameters())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/xf/gcbfh98s6n53wh5f2hpb84nh0000gn/T/ipykernel_23539/4274117446.py:2: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  train_x, train_y = torch.tensor(train_x, dtype=torch.float32), torch.tensor(train_y, dtype=torch.float32)\n"
     ]
    }
   ],
   "source": [
    "#convert datatype\n",
    "train_x, train_y = torch.tensor(train_x, dtype=torch.float32), torch.tensor(train_y, dtype=torch.float32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#training loop\n",
    "n_epochs = 500\n",
    "train_losses = []\n",
    "test_losses = []\n",
    "\n",
    "for _ in range(n_epochs):\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    logits = mlp_model.forward(train_x)\n",
    "    loss = criterion(logits.view(-1), train_y)\n",
    "    train_losses.append(loss.item())\n",
    "    #validation\n",
    "    #history\n",
    "    with torch.no_grad():\n",
    "        history = train_x[-1].tolist() + train_y[-1][None].tolist()\n",
    "\n",
    "        y_pred_values = []\n",
    "        y_true = []\n",
    "        for i in range(len(test)):\n",
    "\n",
    "            test_points = torch.tensor(history[-n_input:], dtype=torch.float32).view(1, n_input)\n",
    "            yhat =  mlp_model.forward(test_points)\n",
    "            history.append(test[i][0])\n",
    "            y_pred_values.append(yhat.item())\n",
    "            y_true.append(test[i][0])\n",
    "\n",
    "        y_pred_values = torch.tensor(y_pred_values, dtype=torch.float32)\n",
    "        y_true = torch.tensor(y_true, dtype=torch.float32)\n",
    "        test_loss = criterion(y_pred_values, y_true)\n",
    "        test_losses.append(test_loss.item())\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "\n",
    "plt.plot(train_losses, label='Train Loss')\n",
    "plt.plot(test_losses, label='Test Loss')\n",
    "\n",
    "# Adding labels and legend\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Losses')\n",
    "plt.title('Train and Valid loss per epochs')\n",
    "plt.legend()\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([3459., 3458., 4002., 4564., 4221., 4529., 4466., 4137., 4126., 4259.,\n",
       "         4240., 4936.]),\n",
       " tensor(3031.))"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_x[0], train_y[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([3458., 4002., 4564., 4221., 4529., 4466., 4137., 4126., 4259., 4240.,\n",
       "         4936., 3031.]),\n",
       " tensor(3261.))"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_x[1], train_y[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = test.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11491.0"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_y[-1].to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11491.0]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_y[-1][None].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([12])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#history\n",
    "history = train_x[-1].tolist() + train_y[-1][None].tolist()\n",
    "len(history)\n",
    "torch.tensor(history[-n_input:], dtype=torch.float32).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([13545])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss : 2197143.25\n"
     ]
    }
   ],
   "source": [
    "#history\n",
    "history = train_x[-1].tolist() + train_y[-1][None].tolist()\n",
    "\n",
    "y_pred_values = []\n",
    "y_true = []\n",
    "for i in range(len(test)):\n",
    "\n",
    "    test_points = torch.tensor(history[-n_input:], dtype=torch.float32).view(1, n_input)\n",
    "    yhat =  mlp_model.forward(test_points)\n",
    "    history.append(test[i][0])\n",
    "    y_pred_values.append(yhat.item())\n",
    "    y_true.append(test[i][0])\n",
    "\n",
    "y_pred_values = torch.tensor(y_pred_values, dtype=torch.float32)\n",
    "y_true = torch.tensor(y_true, dtype=torch.float32)\n",
    "test_loss = criterion(y_pred_values, y_true)\n",
    "\n",
    "print(f\"Test loss : {test_loss}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}