deep-learning/1.lstm.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.LSTMCell(size_layer, state_is_tuple = False)\n",
    "\n",
    "        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 = tf.contrib.rnn.DropoutWrapper(\n",
    "            rnn_cells, output_keep_prob = forget_bias\n",
    "        )\n",
    "        self.hidden_layer = tf.placeholder(\n",
    "            tf.float32, (None, num_layers * 2 * size_layer)\n",
    "        )\n",
    "        self.outputs, self.last_state = tf.nn.dynamic_rnn(\n",
    "            drop, self.X, initial_state = self.hidden_layer, dtype = tf.float32\n",
    "        )\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 = np.zeros((1, num_layers * 2 * 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.hidden_layer: init_value,\n",
    "                },\n",
    "            )        \n",
    "            init_value = last_state\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 = np.zeros((1, num_layers * 2 * 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.hidden_layer: init_value,\n",
    "            },\n",
    "        )\n",
    "        init_value = last_state\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.hidden_layer: init_value,\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 = last_state\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.hidden_layer: init_value,\n",
    "            },\n",
    "        )\n",
    "        init_value = last_state\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 10:02:17.549519 140290267916096 deprecation.py:323] From <ipython-input-6-d01d21f09afe>:12: LSTMCell.__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.LSTMCell, and will be replaced by that in Tensorflow 2.0.\n",
      "W0812 10:02:17.551540 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f975091ada0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:02:17.552432 140290267916096 deprecation.py:323] From <ipython-input-6-d01d21f09afe>: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 10:02:19.808033 140290267916096 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 10:02:19.816455 140290267916096 deprecation.py:323] From <ipython-input-6-d01d21f09afe>:27: 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 10:02:20.147778 140290267916096 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 10:02:20.154457 140290267916096 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:961: 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 10:02:20.564182 140290267916096 deprecation.py:323] From <ipython-input-6-d01d21f09afe>:29: 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:10<00:00,  4.33it/s, acc=97.2, cost=0.00221]\n",
      "W0812 10:03:39.929984 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f975091add8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:09<00:00,  4.33it/s, acc=97.4, cost=0.00193]\n",
      "W0812 10:04:50.024182 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f974694f240>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:09<00:00,  4.34it/s, acc=97.2, cost=0.00212]\n",
      "W0812 10:05:59.904235 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f9746a5af28>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:09<00:00,  4.30it/s, acc=97.3, cost=0.00195]\n",
      "W0812 10:07:10.197728 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f9704151390>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:09<00:00,  4.31it/s, acc=97.2, cost=0.00208]\n",
      "W0812 10:08:20.024446 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f96b8051f98>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:09<00:00,  4.31it/s, acc=97.1, cost=0.00224]\n",
      "W0812 10:09:30.567560 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f96a40a6fd0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:09<00:00,  4.30it/s, acc=97, cost=0.00229]  \n",
      "W0812 10:10:40.653531 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f968d66ac88>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:09<00:00,  4.23it/s, acc=97.5, cost=0.00168]\n",
      "W0812 10:11:50.874499 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f96941b8438>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:10<00:00,  4.32it/s, acc=97.3, cost=0.00193]\n",
      "W0812 10:13:01.677561 140290267916096 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f968b7442e8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:09<00:00,  4.28it/s, acc=97.8, cost=0.00115]\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
}