deep-learning/2.bidirectional-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",
    "        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 * 2 * size_layer)\n",
    "        )\n",
    "        self.forward_hidden_layer = tf.placeholder(\n",
    "            tf.float32, shape = (None, num_layers * 2 * 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 * 2 * size_layer))\n",
    "        init_value_backward = 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.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 * 2 * size_layer))\n",
    "    init_value_backward = 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.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 10:20:04.613218 140016646534976 deprecation.py:323] From <ipython-input-6-32a8ad1d5669>: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:20:04.617547 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f579b74fd68>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:20:04.620435 140016646534976 deprecation.py:323] From <ipython-input-6-32a8ad1d5669>: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",
      "W0812 10:20:04.623959 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f579b6efa20>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0812 10:20:04.949644 140016646534976 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:20:04.954938 140016646534976 deprecation.py:323] From <ipython-input-6-32a8ad1d5669>: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 10:20:04.955546 140016646534976 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 10:20:05.149145 140016646534976 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:20:05.156026 140016646534976 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:20:05.712592 140016646534976 deprecation.py:323] From <ipython-input-6-32a8ad1d5669>: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:39<00:00,  3.04it/s, acc=97.8, cost=0.00113] \n",
      "W0812 10:21:46.695034 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f58216a3208>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:21:46.695935 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f5790ef9e10>: 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:40<00:00,  3.03it/s, acc=97.1, cost=0.00187] \n",
      "W0812 10:23:27.984155 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f57919d69e8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:23:27.985092 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f57008a7b70>: 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:40<00:00,  2.97it/s, acc=97.8, cost=0.00118] \n",
      "W0812 10:26:50.307250 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f5791f0d2e8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:26:50.308161 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56dbd71160>: 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:40<00:00,  2.97it/s, acc=97.1, cost=0.00237]\n",
      "W0812 10:28:31.638492 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56dbe750b8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:28:31.639337 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56d982db38>: 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:37<00:00,  3.11it/s, acc=97.5, cost=0.00143] \n",
      "W0812 10:30:09.934609 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56d99130b8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:30:09.935530 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56d7b95320>: 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:39<00:00,  3.01it/s, acc=97.4, cost=0.00163] \n",
      "W0812 10:31:50.447502 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56d7384cf8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:31:50.448328 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56d56a2748>: 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:38<00:00,  3.05it/s, acc=96.6, cost=0.00322] \n",
      "W0812 10:33:30.276075 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56d4e9bba8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:33:30.276944 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56d2868da0>: 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:38<00:00,  3.07it/s, acc=97.7, cost=0.00133] \n",
      "W0812 10:35:09.746517 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56d290ccf8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 10:35:09.747369 140016646534976 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f56d03129b0>: 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:39<00:00,  3.03it/s, acc=97.5, cost=0.00142] \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
}