deep-learning/5.bidirectional-gru.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import warnings\n",
    "\n",
    "if not sys.warnoptions:\n",
    "    warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from datetime import datetime\n",
    "from datetime import timedelta\n",
    "from tqdm import tqdm\n",
    "sns.set()\n",
    "tf.compat.v1.random.set_random_seed(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>Adj Close</th>\n",
       "      <th>Volume</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2016-11-02</td>\n",
       "      <td>778.200012</td>\n",
       "      <td>781.650024</td>\n",
       "      <td>763.450012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>1872400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2016-11-03</td>\n",
       "      <td>767.250000</td>\n",
       "      <td>769.950012</td>\n",
       "      <td>759.030029</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>1943200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2016-11-04</td>\n",
       "      <td>750.659973</td>\n",
       "      <td>770.359985</td>\n",
       "      <td>750.560974</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>2134800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2016-11-07</td>\n",
       "      <td>774.500000</td>\n",
       "      <td>785.190002</td>\n",
       "      <td>772.549988</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>1585100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2016-11-08</td>\n",
       "      <td>783.400024</td>\n",
       "      <td>795.632996</td>\n",
       "      <td>780.190002</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>1350800</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Date        Open        High         Low       Close   Adj Close  \\\n",
       "0  2016-11-02  778.200012  781.650024  763.450012  768.700012  768.700012   \n",
       "1  2016-11-03  767.250000  769.950012  759.030029  762.130005  762.130005   \n",
       "2  2016-11-04  750.659973  770.359985  750.560974  762.020020  762.020020   \n",
       "3  2016-11-07  774.500000  785.190002  772.549988  782.520020  782.520020   \n",
       "4  2016-11-08  783.400024  795.632996  780.190002  790.510010  790.510010   \n",
       "\n",
       "    Volume  \n",
       "0  1872400  \n",
       "1  1943200  \n",
       "2  2134800  \n",
       "3  1585100  \n",
       "4  1350800  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('../dataset/GOOG-year.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.112708</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.090008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.089628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.160459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.188066</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0\n",
       "0  0.112708\n",
       "1  0.090008\n",
       "2  0.089628\n",
       "3  0.160459\n",
       "4  0.188066"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minmax = MinMaxScaler().fit(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = minmax.transform(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = pd.DataFrame(df_log)\n",
    "df_log.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split train and test\n",
    "\n",
    "I will cut the dataset to train and test datasets,\n",
    "\n",
    "1. Train dataset derived from starting timestamp until last 30 days\n",
    "2. Test dataset derived from last 30 days until end of the dataset\n",
    "\n",
    "So we will let the model do forecasting based on last 30 days, and we will going to repeat the experiment for 10 times. You can increase it locally if you want, and tuning parameters will help you by a lot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((252, 7), (222, 1), (30, 1))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_size = 30\n",
    "simulation_size = 10\n",
    "\n",
    "df_train = df_log.iloc[:-test_size]\n",
    "df_test = df_log.iloc[-test_size:]\n",
    "df.shape, df_train.shape, df_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(\n",
    "        self,\n",
    "        learning_rate,\n",
    "        num_layers,\n",
    "        size,\n",
    "        size_layer,\n",
    "        output_size,\n",
    "        forget_bias = 0.1,\n",
    "    ):\n",
    "        def lstm_cell(size_layer):\n",
    "            return tf.nn.rnn_cell.GRUCell(size_layer)\n",
    "\n",
    "        backward_rnn_cells = tf.nn.rnn_cell.MultiRNNCell(\n",
    "            [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "            state_is_tuple = False,\n",
    "        )\n",
    "        forward_rnn_cells = tf.nn.rnn_cell.MultiRNNCell(\n",
    "            [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "            state_is_tuple = False,\n",
    "        )\n",
    "        self.X = tf.placeholder(tf.float32, (None, None, size))\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "        drop_backward = tf.contrib.rnn.DropoutWrapper(\n",
    "            backward_rnn_cells, output_keep_prob = forget_bias\n",
    "        )\n",
    "        forward_backward = tf.contrib.rnn.DropoutWrapper(\n",
    "            forward_rnn_cells, output_keep_prob = forget_bias\n",
    "        )\n",
    "        self.backward_hidden_layer = tf.placeholder(\n",
    "            tf.float32, shape = (None, num_layers * size_layer)\n",
    "        )\n",
    "        self.forward_hidden_layer = tf.placeholder(\n",
    "            tf.float32, shape = (None, num_layers * size_layer)\n",
    "        )\n",
    "        self.outputs, self.last_state = tf.nn.bidirectional_dynamic_rnn(\n",
    "            forward_backward,\n",
    "            drop_backward,\n",
    "            self.X,\n",
    "            initial_state_fw = self.forward_hidden_layer,\n",
    "            initial_state_bw = self.backward_hidden_layer,\n",
    "            dtype = tf.float32,\n",
    "        )\n",
    "        self.outputs = tf.concat(self.outputs, 2)\n",
    "        self.logits = tf.layers.dense(self.outputs[-1], output_size)\n",
    "        self.cost = tf.reduce_mean(tf.square(self.Y - self.logits))\n",
    "        self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(\n",
    "            self.cost\n",
    "        )\n",
    "        \n",
    "def calculate_accuracy(real, predict):\n",
    "    real = np.array(real) + 1\n",
    "    predict = np.array(predict) + 1\n",
    "    percentage = 1 - np.sqrt(np.mean(np.square((real - predict) / real)))\n",
    "    return percentage * 100\n",
    "\n",
    "def anchor(signal, weight):\n",
    "    buffer = []\n",
    "    last = signal[0]\n",
    "    for i in signal:\n",
    "        smoothed_val = last * weight + (1 - weight) * i\n",
    "        buffer.append(smoothed_val)\n",
    "        last = smoothed_val\n",
    "    return buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_layers = 1\n",
    "size_layer = 128\n",
    "timestamp = 5\n",
    "epoch = 300\n",
    "dropout_rate = 0.8\n",
    "future_day = test_size\n",
    "learning_rate = 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forecast():\n",
    "    tf.reset_default_graph()\n",
    "    modelnn = Model(\n",
    "        learning_rate, num_layers, df_log.shape[1], size_layer, df_log.shape[1], dropout_rate\n",
    "    )\n",
    "    sess = tf.InteractiveSession()\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    date_ori = pd.to_datetime(df.iloc[:, 0]).tolist()\n",
    "\n",
    "    pbar = tqdm(range(epoch), desc = 'train loop')\n",
    "    for i in pbar:\n",
    "        init_value_forward = np.zeros((1, num_layers * size_layer))\n",
    "        init_value_backward = np.zeros((1, num_layers * size_layer))\n",
    "        total_loss, total_acc = [], []\n",
    "        for k in range(0, df_train.shape[0] - 1, timestamp):\n",
    "            index = min(k + timestamp, df_train.shape[0] - 1)\n",
    "            batch_x = np.expand_dims(\n",
    "                df_train.iloc[k : index, :].values, axis = 0\n",
    "            )\n",
    "            batch_y = df_train.iloc[k + 1 : index + 1, :].values\n",
    "            logits, last_state, _, loss = sess.run(\n",
    "                [modelnn.logits, modelnn.last_state, modelnn.optimizer, modelnn.cost],\n",
    "                feed_dict = {\n",
    "                    modelnn.X: batch_x,\n",
    "                    modelnn.Y: batch_y,\n",
    "                    modelnn.backward_hidden_layer: init_value_backward,\n",
    "                    modelnn.forward_hidden_layer: init_value_forward,\n",
    "                },\n",
    "            )        \n",
    "            init_value_forward = last_state[0]\n",
    "            init_value_backward = last_state[1]\n",
    "            total_loss.append(loss)\n",
    "            total_acc.append(calculate_accuracy(batch_y[:, 0], logits[:, 0]))\n",
    "        pbar.set_postfix(cost = np.mean(total_loss), acc = np.mean(total_acc))\n",
    "    \n",
    "    future_day = test_size\n",
    "\n",
    "    output_predict = np.zeros((df_train.shape[0] + future_day, df_train.shape[1]))\n",
    "    output_predict[0] = df_train.iloc[0]\n",
    "    upper_b = (df_train.shape[0] // timestamp) * timestamp\n",
    "    init_value_forward = np.zeros((1, num_layers * size_layer))\n",
    "    init_value_backward = np.zeros((1, num_layers * size_layer))\n",
    "\n",
    "    for k in range(0, (df_train.shape[0] // timestamp) * timestamp, timestamp):\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(\n",
    "                    df_train.iloc[k : k + timestamp], axis = 0\n",
    "                ),\n",
    "                modelnn.backward_hidden_layer: init_value_backward,\n",
    "                modelnn.forward_hidden_layer: init_value_forward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state[0]\n",
    "        init_value_backward = last_state[1]\n",
    "        output_predict[k + 1 : k + timestamp + 1] = out_logits\n",
    "\n",
    "    if upper_b != df_train.shape[0]:\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(df_train.iloc[upper_b:], axis = 0),\n",
    "                modelnn.backward_hidden_layer: init_value_backward,\n",
    "                modelnn.forward_hidden_layer: init_value_forward,\n",
    "            },\n",
    "        )\n",
    "        output_predict[upper_b + 1 : df_train.shape[0] + 1] = out_logits\n",
    "        future_day -= 1\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "\n",
    "    init_value_forward = last_state[0]\n",
    "    init_value_backward = last_state[1]\n",
    "    \n",
    "    for i in range(future_day):\n",
    "        o = output_predict[-future_day - timestamp + i:-future_day + i]\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(o, axis = 0),\n",
    "                modelnn.backward_hidden_layer: init_value_backward,\n",
    "                modelnn.forward_hidden_layer: init_value_forward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state[0]\n",
    "        init_value_backward = last_state[1]\n",
    "        output_predict[-future_day + i] = out_logits[-1]\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "    \n",
    "    output_predict = minmax.inverse_transform(output_predict)\n",
    "    deep_future = anchor(output_predict[:, 0], 0.3)\n",
    "    \n",
    "    return deep_future[-test_size:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0812 17:04:18.991346 140383403915072 deprecation.py:323] From <ipython-input-6-5c392a5d20ef>:12: GRUCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.GRUCell, and will be replaced by that in Tensorflow 2.0.\n",
      "W0812 17:04:18.995361 140383403915072 deprecation.py:323] From <ipython-input-6-5c392a5d20ef>:16: MultiRNNCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.StackedRNNCells, and will be replaced by that in Tensorflow 2.0.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0812 17:04:19.316777 140383403915072 lazy_loader.py:50] \n",
      "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "  * https://github.com/tensorflow/io (for I/O related ops)\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "W0812 17:04:19.322190 140383403915072 deprecation.py:323] From <ipython-input-6-5c392a5d20ef>:42: bidirectional_dynamic_rnn (from tensorflow.python.ops.rnn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `keras.layers.Bidirectional(keras.layers.RNN(cell))`, which is equivalent to this API\n",
      "W0812 17:04:19.322940 140383403915072 deprecation.py:323] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn.py:464: dynamic_rnn (from tensorflow.python.ops.rnn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `keras.layers.RNN(cell)`, which is equivalent to this API\n",
      "W0812 17:04:19.515542 140383403915072 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0812 17:04:19.522486 140383403915072 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:564: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0812 17:04:19.531559 140383403915072 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:574: calling Zeros.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0812 17:04:19.763414 140383403915072 deprecation.py:323] From <ipython-input-6-5c392a5d20ef>:45: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dense instead.\n",
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  2.98it/s, acc=97.1, cost=0.00199]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:39<00:00,  3.02it/s, acc=76.2, cost=0.139] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  3.00it/s, acc=97.1, cost=0.00205]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  2.99it/s, acc=95.3, cost=0.00587]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  2.97it/s, acc=96.2, cost=0.00386]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  2.99it/s, acc=97.1, cost=0.00196]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  2.98it/s, acc=96.7, cost=0.0032] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:39<00:00,  3.00it/s, acc=85.2, cost=0.0599] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:40<00:00,  2.99it/s, acc=97.6, cost=0.00142]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:38<00:00,  3.03it/s, acc=97.7, cost=0.00138]\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "for i in range(simulation_size):\n",
    "    print('simulation %d'%(i + 1))\n",
    "    results.append(forecast())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracies = [calculate_accuracy(df['Close'].iloc[-test_size:].values, r) for r in results]\n",
    "\n",
    "plt.figure(figsize = (15, 5))\n",
    "for no, r in enumerate(results):\n",
    "    plt.plot(r, label = 'forecast %d'%(no + 1))\n",
    "plt.plot(df['Close'].iloc[-test_size:].values, label = 'true trend', c = 'black')\n",
    "plt.legend()\n",
    "plt.title('average accuracy: %.4f'%(np.mean(accuracies)))\n",
    "plt.show()"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}