deep-learning/10.lstm-seq2seq.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": 10,
   "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",
    "        _, last_state = tf.nn.dynamic_rnn(\n",
    "            drop, self.X, initial_state = self.hidden_layer, dtype = tf.float32\n",
    "        )\n",
    "        \n",
    "        with tf.variable_scope('decoder', reuse = False):\n",
    "            rnn_cells_dec = tf.nn.rnn_cell.MultiRNNCell(\n",
    "                [lstm_cell(size_layer) for _ in range(num_layers)], state_is_tuple = False\n",
    "            )\n",
    "            drop_dec = tf.contrib.rnn.DropoutWrapper(\n",
    "                rnn_cells_dec, output_keep_prob = forget_bias\n",
    "            )\n",
    "            self.outputs, self.last_state = tf.nn.dynamic_rnn(\n",
    "                drop_dec, self.X, initial_state = last_state, dtype = tf.float32\n",
    "            )\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": 11,
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0813 21:47:16.666563 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f69f3ff7908>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 21:47:16.753933 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f69fd7aa860>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 21:47:16.834197 140095600830272 deprecation.py:323] From <ipython-input-10-f89ab136c7c7>:41: 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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:36<00:00,  3.11it/s, acc=97.9, cost=0.00101] \n",
      "W0813 21:48:54.353741 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f69fd79e9e8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 21:48:54.437589 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f69f2dedeb8>: 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:38<00:00,  3.05it/s, acc=98.3, cost=0.00069] \n",
      "W0813 21:50:34.225154 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f69f35367f0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 21:50:34.305581 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f696417da20>: 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:38<00:00,  3.06it/s, acc=97.7, cost=0.00117] \n",
      "W0813 21:52:13.825603 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f69e80d60f0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 21:52:13.908980 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f695cdf5518>: 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:37<00:00,  3.08it/s, acc=98.4, cost=0.000614]\n",
      "W0813 21:53:52.767824 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f695d0ed1d0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 21:53:52.849310 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f693eab10f0>: 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:38<00:00,  3.03it/s, acc=98.2, cost=0.000755]\n",
      "W0813 21:55:32.572073 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f693ed38cf8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 21:55:32.654169 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f693c7376a0>: 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:38<00:00,  3.07it/s, acc=98.3, cost=0.000681]\n",
      "W0813 21:57:12.073868 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f693ce4e080>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 21:57:12.156364 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f693a339e80>: 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:38<00:00,  3.01it/s, acc=97.7, cost=0.00126] \n",
      "W0813 21:58:51.933507 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f693ab0ffd0>: 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": [
      "W0813 21:58:52.153095 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f693801aba8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "train loop: 100%|██████████| 300/300 [01:38<00:00,  3.04it/s, acc=98.5, cost=0.000589]\n",
      "W0813 22:00:31.650501 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f69380c7f98>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:00:31.732362 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6935bf8ef0>: 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.01it/s, acc=98.4, cost=0.000625]\n",
      "W0813 22:02:11.445839 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f6936470550>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0813 22:02:11.528598 140095600830272 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f693387feb8>: 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.08it/s, acc=96.8, cost=0.0027]  \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": 13,
   "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
}