blitz/examples/stocks-blstm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from blitz.modules import BayesianLSTM\n",
    "from blitz.utils import variational_estimator\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from collections import deque"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Archive:  stock-time-series-20050101-to-20171231.zip\n",
      "  inflating: AABA_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: AAPL_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: AMZN_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: AXP_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: BA_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: CAT_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: CSCO_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: CVX_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: DIS_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: GE_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: GOOGL_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: GS_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: HD_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: IBM_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: INTC_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: JNJ_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: JPM_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: KO_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: MCD_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: MMM_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: MRK_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: MSFT_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: NKE_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: PFE_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: PG_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: TRV_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: UNH_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: UTX_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: VZ_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: WMT_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: XOM_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: all_stocks_2006-01-01_to_2018-01-01.csv  \n",
      "  inflating: all_stocks_2017-01-01_to_2018-01-01.csv  \n"
     ]
    }
   ],
   "source": [
    "!cd data && unzip stock-time-series-20050101-to-20171231"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "REMEMBER TO DOWNLOAD THE DATASET AT KAGGLE AT THIS LINK:\n",
    "https://www.kaggle.com/szrlee/stock-time-series-20050101-to-20171231\n",
    "\"\"\"\n",
    "amazon=\"data/AMZN_2006-01-01_to_2018-01-01.csv\"\n",
    "ibm=\"data/IBM_2006-01-01_to_2018-01-01.csv\"\n",
    "df = pd.read_csv(ibm)\n",
    "\n",
    "window_size = 21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>Date</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Close</th>\n",
       "      <th>Volume</th>\n",
       "      <th>Name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2006-01-03</td>\n",
       "      <td>82.45</td>\n",
       "      <td>82.55</td>\n",
       "      <td>80.81</td>\n",
       "      <td>82.06</td>\n",
       "      <td>11715200</td>\n",
       "      <td>IBM</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2006-01-04</td>\n",
       "      <td>82.20</td>\n",
       "      <td>82.50</td>\n",
       "      <td>81.33</td>\n",
       "      <td>81.95</td>\n",
       "      <td>9840600</td>\n",
       "      <td>IBM</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2006-01-05</td>\n",
       "      <td>81.40</td>\n",
       "      <td>82.90</td>\n",
       "      <td>81.00</td>\n",
       "      <td>82.50</td>\n",
       "      <td>7213500</td>\n",
       "      <td>IBM</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2006-01-06</td>\n",
       "      <td>83.95</td>\n",
       "      <td>85.03</td>\n",
       "      <td>83.41</td>\n",
       "      <td>84.95</td>\n",
       "      <td>8197400</td>\n",
       "      <td>IBM</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2006-01-09</td>\n",
       "      <td>84.10</td>\n",
       "      <td>84.25</td>\n",
       "      <td>83.38</td>\n",
       "      <td>83.73</td>\n",
       "      <td>6858200</td>\n",
       "      <td>IBM</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Date   Open   High    Low  Close    Volume Name\n",
       "0  2006-01-03  82.45  82.55  80.81  82.06  11715200  IBM\n",
       "1  2006-01-04  82.20  82.50  81.33  81.95   9840600  IBM\n",
       "2  2006-01-05  81.40  82.90  81.00  82.50   7213500  IBM\n",
       "3  2006-01-06  83.95  85.03  83.41  84.95   8197400  IBM\n",
       "4  2006-01-09  84.10  84.25  83.38  83.73   6858200  IBM"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "close_prices = df[\"Close\"]\n",
    "scaler = StandardScaler()\n",
    "\n",
    "close_prices_arr = np.array(close_prices).reshape(-1, 1)\n",
    "close_prices = scaler.fit_transform(close_prices_arr)\n",
    "\n",
    "close_prices_unscaled = df[\"Close\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_timestamps_ds(series, \n",
    "                         timestep_size=window_size):\n",
    "    time_stamps = []\n",
    "    labels = []\n",
    "    aux_deque = deque(maxlen=timestep_size)\n",
    "    \n",
    "    #starting the timestep deque\n",
    "    for i in range(timestep_size):\n",
    "        aux_deque.append(0)\n",
    "    \n",
    "    #feed the timestamps list\n",
    "    for i in range(len(series)-1):\n",
    "        aux_deque.append(series[i])\n",
    "        time_stamps.append(list(aux_deque))\n",
    "    \n",
    "    #feed the labels lsit\n",
    "    for i in range(len(series)-1):\n",
    "        labels.append(series[i + 1])\n",
    "    \n",
    "    assert len(time_stamps) == len(labels), \"Something went wrong\"\n",
    "    \n",
    "    #torch-tensoring it\n",
    "    features = torch.tensor(time_stamps[timestep_size:]).float()\n",
    "    labels = torch.tensor(labels[timestep_size:]).float()\n",
    "    \n",
    "    return features, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "@variational_estimator\n",
    "class NN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(NN, self).__init__()\n",
    "        self.lstm_1 = BayesianLSTM(1, 10, prior_sigma_1=1, prior_pi=1, posterior_rho_init=-3.0)\n",
    "        self.linear = nn.Linear(10, 1)\n",
    "            \n",
    "    def forward(self, x):\n",
    "        x_, _ = self.lstm_1(x)\n",
    "        \n",
    "        #gathering only the latent end-of-sequence for the linear layer\n",
    "        x_ = x_[:, -1, :]\n",
    "        x_ = self.linear(x_)\n",
    "        return x_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xs, ys = create_timestamps_ds(close_prices)\n",
    "X_train, X_test, y_train, y_test = train_test_split(Xs,\n",
    "                                                    ys,\n",
    "                                                    test_size=.25,\n",
    "                                                    random_state=42,\n",
    "                                                    shuffle=False)\n",
    "\n",
    "\n",
    "\n",
    "ds = torch.utils.data.TensorDataset(X_train, y_train)\n",
    "dataloader_train = torch.utils.data.DataLoader(ds, batch_size=8, shuffle=True)\n",
    "\n",
    "net = NN()\n",
    "\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(net.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration: 250 Val-loss: 0.0467\n",
      "Iteration: 500 Val-loss: 0.0362\n",
      "Iteration: 750 Val-loss: 0.0436\n",
      "Iteration: 1000 Val-loss: 0.0078\n",
      "Iteration: 1250 Val-loss: 0.0050\n",
      "Iteration: 1500 Val-loss: 0.0047\n",
      "Iteration: 1750 Val-loss: 0.0076\n",
      "Iteration: 2000 Val-loss: 0.0058\n",
      "Iteration: 2250 Val-loss: 0.0065\n",
      "Iteration: 2500 Val-loss: 0.0061\n",
      "Iteration: 2750 Val-loss: 0.0089\n"
     ]
    }
   ],
   "source": [
    "iteration = 0\n",
    "for epoch in range(10):\n",
    "    for i, (datapoints, labels) in enumerate(dataloader_train):\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        loss = net.sample_elbo(inputs=datapoints,\n",
    "                               labels=labels,\n",
    "                               criterion=criterion,\n",
    "                               sample_nbr=3,\n",
    "                               complexity_cost_weight=1/X_train.shape[0])\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        iteration += 1\n",
    "        if iteration%250==0:\n",
    "            preds_test = net(X_test)[:,0].unsqueeze(1)\n",
    "            loss_test = criterion(preds_test, y_test)\n",
    "            print(\"Iteration: {} Val-loss: {:.4f}\".format(str(iteration), loss_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pred_unscaled\n",
    "original = close_prices_unscaled[1:][window_size:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_pred = pd.DataFrame(original)\n",
    "df_pred[\"Date\"] = df.Date\n",
    "df[\"Date\"] = pd.to_datetime(df_pred[\"Date\"])\n",
    "df_pred = df_pred.reset_index()\n",
    "#df_pred = df_pred.set_index('Date')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pred_stock_future(X_test,\n",
    "                                           future_length,\n",
    "                                           sample_nbr=10):\n",
    "    \n",
    "    #sorry for that, window_size is a global variable, and so are X_train and Xs\n",
    "    global window_size\n",
    "    global X_train\n",
    "    global Xs\n",
    "    global scaler\n",
    "    \n",
    "    #creating auxiliar variables for future prediction\n",
    "    preds_test = []\n",
    "    test_begin = X_test[0:1, :, :]\n",
    "    test_deque = deque(test_begin[0,:,0].tolist(), maxlen=window_size)\n",
    "\n",
    "    idx_pred = np.arange(len(X_train), len(Xs))\n",
    "    \n",
    "    #predict it and append to list\n",
    "    for i in range(len(X_test)):\n",
    "        #print(i)\n",
    "        as_net_input = torch.tensor(test_deque).unsqueeze(0).unsqueeze(2)\n",
    "        pred = [net(as_net_input).cpu().item() for i in range(sample_nbr)]\n",
    "        \n",
    "        \n",
    "        test_deque.append(torch.tensor(pred).mean().cpu().item())\n",
    "        preds_test.append(pred)\n",
    "        \n",
    "        if i % future_length == 0:\n",
    "            #our inptus become the i index of our X_test\n",
    "            #That tweak just helps us with shape issues\n",
    "            test_begin = X_test[i:i+1, :, :]\n",
    "            test_deque = deque(test_begin[0,:,0].tolist(), maxlen=window_size)\n",
    "\n",
    "    #preds_test = np.array(preds_test).reshape(-1, 1)\n",
    "    #preds_test_unscaled = scaler.inverse_transform(preds_test)\n",
    "    \n",
    "    return idx_pred, preds_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_confidence_intervals(preds_test, ci_multiplier):\n",
    "    global scaler\n",
    "    \n",
    "    preds_test = torch.tensor(preds_test)\n",
    "    \n",
    "    pred_mean = preds_test.mean(1)\n",
    "    pred_std = preds_test.std(1).detach().cpu().numpy()\n",
    "\n",
    "    pred_std = torch.tensor((pred_std))\n",
    "    #print(pred_std)\n",
    "    \n",
    "    upper_bound = pred_mean + (pred_std * ci_multiplier)\n",
    "    lower_bound = pred_mean - (pred_std * ci_multiplier)\n",
    "    #gather unscaled confidence intervals\n",
    "\n",
    "    pred_mean_final = pred_mean.unsqueeze(1).detach().cpu().numpy()\n",
    "    pred_mean_unscaled = scaler.inverse_transform(pred_mean_final)\n",
    "\n",
    "    upper_bound_unscaled = upper_bound.unsqueeze(1).detach().cpu().numpy()\n",
    "    upper_bound_unscaled = scaler.inverse_transform(upper_bound_unscaled)\n",
    "    \n",
    "    lower_bound_unscaled = lower_bound.unsqueeze(1).detach().cpu().numpy()\n",
    "    lower_bound_unscaled = scaler.inverse_transform(lower_bound_unscaled)\n",
    "    \n",
    "    return pred_mean_unscaled, upper_bound_unscaled, lower_bound_unscaled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "future_length=7\n",
    "sample_nbr=4\n",
    "ci_multiplier=5\n",
    "idx_pred, preds_test = pred_stock_future(X_test, future_length, sample_nbr)\n",
    "pred_mean_unscaled, upper_bound_unscaled, lower_bound_unscaled = get_confidence_intervals(preds_test,\n",
    "                                                                                          ci_multiplier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9053333333333333 our predictions are in our confidence interval\n"
     ]
    }
   ],
   "source": [
    "y = np.array(df.Close[-750:]).reshape(-1, 1)\n",
    "under_upper = upper_bound_unscaled > y\n",
    "over_lower = lower_bound_unscaled < y\n",
    "total = (under_upper == over_lower)\n",
    "\n",
    "print(\"{} our predictions are in our confidence interval\".format(np.mean(total)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f1aecb7fac0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "dark"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = {\"ytick.color\" : \"w\",\n",
    "          \"xtick.color\" : \"w\",\n",
    "          \"axes.labelcolor\" : \"w\",\n",
    "          \"axes.edgecolor\" : \"w\"}\n",
    "\n",
    "plt.rcParams.update(params)\n",
    "\n",
    "plt.title(\"IBM Stock prices\", color=\"white\")\n",
    "\n",
    "plt.plot(df_pred.index,\n",
    "         df_pred.Close,\n",
    "         color='black',\n",
    "         label=\"Real\")\n",
    "\n",
    "plt.plot(idx_pred,\n",
    "         pred_mean_unscaled,\n",
    "         label=\"Prediction for {} days, than consult\".format(future_length),\n",
    "         color=\"red\")\n",
    "\n",
    "plt.fill_between(x=idx_pred,\n",
    "                 y1=upper_bound_unscaled[:,0],\n",
    "                 y2=lower_bound_unscaled[:,0],\n",
    "                 facecolor='green',\n",
    "                 label=\"Confidence interval\",\n",
    "                 alpha=0.5)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f1aecb52520>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "dark"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "params = {\"ytick.color\" : \"w\",\n",
    "          \"xtick.color\" : \"w\",\n",
    "          \"axes.labelcolor\" : \"w\",\n",
    "          \"axes.edgecolor\" : \"w\"}\n",
    "plt.rcParams.update(params)\n",
    "\n",
    "plt.title(\"IBM Stock prices\", color=\"white\")\n",
    "\n",
    "\n",
    "plt.fill_between(x=idx_pred,\n",
    "                 y1=upper_bound_unscaled[:,0],\n",
    "                 y2=lower_bound_unscaled[:,0],\n",
    "                 facecolor='green',\n",
    "                 label=\"Confidence interval\",\n",
    "                 alpha=0.75)\n",
    "\n",
    "plt.plot(idx_pred,\n",
    "         df_pred.Close[-len(pred_mean_unscaled):],\n",
    "         label=\"Real\",\n",
    "         alpha=1,\n",
    "         color='black',\n",
    "         linewidth=0.5)\n",
    "\n",
    "plt.plot(idx_pred,\n",
    "         pred_mean_unscaled,\n",
    "         label=\"Prediction for {} days, than consult\".format(future_length),\n",
    "         color=\"red\",\n",
    "         alpha=0.5)\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}