deep-learning/3.lstm-2path.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",
    "        with tf.variable_scope('forward', reuse = False):\n",
    "            rnn_cells_forward = tf.nn.rnn_cell.MultiRNNCell(\n",
    "                [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "                state_is_tuple = False,\n",
    "            )\n",
    "            self.X_forward = tf.placeholder(tf.float32, (None, None, size))\n",
    "            drop_forward = tf.contrib.rnn.DropoutWrapper(\n",
    "                rnn_cells_forward, output_keep_prob = forget_bias\n",
    "            )\n",
    "            self.hidden_layer_forward = tf.placeholder(\n",
    "                tf.float32, (None, num_layers * 2 * size_layer)\n",
    "            )\n",
    "            self.outputs_forward, self.last_state_forward = tf.nn.dynamic_rnn(\n",
    "                drop_forward,\n",
    "                self.X_forward,\n",
    "                initial_state = self.hidden_layer_forward,\n",
    "                dtype = tf.float32,\n",
    "            )\n",
    "\n",
    "        with tf.variable_scope('backward', reuse = False):\n",
    "            rnn_cells_backward = tf.nn.rnn_cell.MultiRNNCell(\n",
    "                [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "                state_is_tuple = False,\n",
    "            )\n",
    "            self.X_backward = tf.placeholder(tf.float32, (None, None, size))\n",
    "            drop_backward = tf.contrib.rnn.DropoutWrapper(\n",
    "                rnn_cells_backward, output_keep_prob = forget_bias\n",
    "            )\n",
    "            self.hidden_layer_backward = tf.placeholder(\n",
    "                tf.float32, (None, num_layers * 2 * size_layer)\n",
    "            )\n",
    "            self.outputs_backward, self.last_state_backward = tf.nn.dynamic_rnn(\n",
    "                drop_backward,\n",
    "                self.X_backward,\n",
    "                initial_state = self.hidden_layer_backward,\n",
    "                dtype = tf.float32,\n",
    "            )\n",
    "\n",
    "        self.outputs = self.outputs_backward - self.outputs_forward\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\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_forward = np.expand_dims(\n",
    "                df_train.iloc[k : index, :].values, axis = 0\n",
    "            )\n",
    "            batch_x_backward = np.expand_dims(\n",
    "                np.flip(df_train.iloc[k : index, :].values, axis = 0), axis = 0\n",
    "            )\n",
    "            batch_y = df_train.iloc[k + 1 : index + 1, :].values\n",
    "            logits, last_state_forward, last_state_backward, _, loss = sess.run(\n",
    "                [\n",
    "                    modelnn.logits,\n",
    "                    modelnn.last_state_forward,\n",
    "                    modelnn.last_state_backward,\n",
    "                    modelnn.optimizer,\n",
    "                    modelnn.cost,\n",
    "                ],\n",
    "                feed_dict = {\n",
    "                    modelnn.X_forward: batch_x_forward,\n",
    "                    modelnn.X_backward: batch_x_backward,\n",
    "                    modelnn.Y: batch_y,\n",
    "                    modelnn.hidden_layer_forward: init_value_forward,\n",
    "                    modelnn.hidden_layer_backward: init_value_backward,\n",
    "                },\n",
    "            )\n",
    "            init_value_forward = last_state_forward\n",
    "            init_value_backward = last_state_backward\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",
    "        batch_x_forward = np.expand_dims(\n",
    "        df_train.iloc[k : k + timestamp, :], axis = 0\n",
    "        )\n",
    "        batch_x_backward = np.expand_dims(\n",
    "            np.flip(df_train.iloc[k : k + timestamp, :].values, axis = 0), axis = 0\n",
    "        )\n",
    "        out_logits, last_state_forward, last_state_backward = sess.run(\n",
    "            [\n",
    "                modelnn.logits,\n",
    "                modelnn.last_state_forward,\n",
    "                modelnn.last_state_backward,\n",
    "            ],\n",
    "            feed_dict = {\n",
    "                modelnn.X_forward: batch_x_forward,\n",
    "                modelnn.X_backward: batch_x_backward,\n",
    "                modelnn.hidden_layer_forward: init_value_forward,\n",
    "                modelnn.hidden_layer_backward: init_value_backward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state_forward\n",
    "        init_value_backward = last_state_backward\n",
    "        output_predict[k + 1 : k + timestamp + 1, :] = out_logits\n",
    "\n",
    "    if upper_b != df_train.shape[0]:\n",
    "        batch_x_forward = np.expand_dims(df_train.iloc[upper_b:, :], axis = 0)\n",
    "        batch_x_backward = np.expand_dims(\n",
    "            np.flip(df_train.iloc[upper_b:, :].values, axis = 0), axis = 0\n",
    "        )\n",
    "        out_logits, last_state_forward, last_state_backward = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state_forward, modelnn.last_state_backward],\n",
    "            feed_dict = {\n",
    "                modelnn.X_forward: batch_x_forward,\n",
    "                modelnn.X_backward: batch_x_backward,\n",
    "                modelnn.hidden_layer_forward: init_value_forward,\n",
    "                modelnn.hidden_layer_backward: init_value_backward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state_forward\n",
    "        init_value_backward = last_state_backward\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_forward\n",
    "    init_value_backward = last_state_backward\n",
    "    \n",
    "    for i in range(future_day):\n",
    "        o = output_predict[-future_day - timestamp + i:-future_day + i]\n",
    "        o_f = np.flip(o, axis = 0)\n",
    "        out_logits, last_state_forward, last_state_backward = sess.run(\n",
    "            [\n",
    "                modelnn.logits,\n",
    "                modelnn.last_state_forward,\n",
    "                modelnn.last_state_backward,\n",
    "            ],\n",
    "            feed_dict = {\n",
    "                modelnn.X_forward: np.expand_dims(o, axis = 0),\n",
    "                modelnn.X_backward: np.expand_dims(o_f, axis = 0),\n",
    "                modelnn.hidden_layer_forward: init_value_forward,\n",
    "                modelnn.hidden_layer_backward: init_value_backward,\n",
    "            },\n",
    "        )\n",
    "        init_value_forward = last_state_forward\n",
    "        init_value_backward = last_state_backward\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 16:41:29.569112 139847292135232 deprecation.py:323] From <ipython-input-6-2e28fdecec52>: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 16:41:29.570642 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f302d208da0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:41:29.571565 139847292135232 deprecation.py:323] From <ipython-input-6-2e28fdecec52>:17: 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 16:41:29.886489 139847292135232 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 16:41:29.889781 139847292135232 deprecation.py:323] From <ipython-input-6-2e28fdecec52>:30: 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 16:41:30.079713 139847292135232 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 16:41:30.086595 139847292135232 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 16:41:30.565006 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f302d1de6d8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:41:30.647609 139847292135232 deprecation.py:323] From <ipython-input-6-2e28fdecec52>:54: 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.02it/s, acc=97.7, cost=0.00132] \n",
      "W0812 16:43:12.068012 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f3022b11fd0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:43:12.148377 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f30229e3080>: 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.02it/s, acc=97.4, cost=0.00157]\n",
      "W0812 16:44:53.274921 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2fdc217b00>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:44:53.357845 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2fdc1bc0f0>: 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.98it/s, acc=97.3, cost=0.00171]\n",
      "W0812 16:46:35.140946 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f847c0240>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:46:35.223572 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f847c00b8>: 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:38<00:00,  3.00it/s, acc=96.5, cost=0.00334] \n",
      "W0812 16:48:14.756632 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f843747f0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:48:14.838256 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f722b19e8>: 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:41<00:00,  2.98it/s, acc=97.9, cost=0.00113]\n",
      "W0812 16:49:56.968556 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f6bd75b70>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:49:57.051066 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f6bd755f8>: 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:40<00:00,  3.01it/s, acc=97.7, cost=0.00145]\n",
      "W0812 16:51:38.877053 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f6a0db3c8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:51:38.959546 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f6976aef0>: 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:41<00:00,  2.98it/s, acc=97.3, cost=0.00172]\n",
      "W0812 16:53:21.123231 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f67bdbcc0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:53:21.205539 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f67258e10>: 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.06it/s, acc=97.8, cost=0.00117]\n",
      "W0812 16:55:00.356067 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f65677da0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:55:00.437367 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f65677898>: 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.05it/s, acc=97.7, cost=0.00127]\n",
      "W0812 16:56:40.365346 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f628e67b8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0812 16:56:40.448274 139847292135232 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f2f628e6320>: 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:40<00:00,  2.97it/s, acc=97.2, cost=0.00216]\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
}