deep-learning/12.lstm-seq2seq-vae.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",
    "        lambda_coeff = 0.5\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",
    "        self.z_mean = tf.layers.dense(last_state, size)\n",
    "        self.z_log_sigma = tf.layers.dense(last_state, size)\n",
    "        \n",
    "        epsilon = tf.random_normal(tf.shape(self.z_log_sigma))\n",
    "        self.z_vector = self.z_mean + tf.exp(self.z_log_sigma)\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",
    "            x = tf.concat([tf.expand_dims(self.z_vector, axis=0), self.X], axis = 1)\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.lambda_coeff = lambda_coeff\n",
    "        \n",
    "        self.kl_loss = -0.5 * tf.reduce_sum(1.0 + 2 * self.z_log_sigma - self.z_mean ** 2 - \n",
    "                             tf.exp(2 * self.z_log_sigma), 1)\n",
    "        self.kl_loss = tf.scalar_mul(self.lambda_coeff, self.kl_loss)\n",
    "        self.cost = tf.reduce_mean(tf.square(self.Y - self.logits) + self.kl_loss)\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_x = np.random.binomial(1, 0.5, batch_x.shape) * batch_x\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",
      "W0816 15:26:45.502804 139658996016960 deprecation.py:323] From <ipython-input-6-d907d7a4dee6>:13: 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",
      "W0816 15:26:45.505823 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f04dbc873c8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:26:45.507445 139658996016960 deprecation.py:323] From <ipython-input-6-d907d7a4dee6>: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": [
      "W0816 15:26:45.829126 139658996016960 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",
      "W0816 15:26:45.832581 139658996016960 deprecation.py:323] From <ipython-input-6-d907d7a4dee6>:28: 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",
      "W0816 15:26:46.024316 139658996016960 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",
      "W0816 15:26:46.031064 139658996016960 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",
      "W0816 15:26:46.507349 139658996016960 deprecation.py:323] From <ipython-input-6-d907d7a4dee6>:31: 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",
      "W0816 15:26:46.696353 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f04778236d8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:26:46.879564 139658996016960 deprecation.py:323] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_grad.py:1205: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "train loop: 100%|██████████| 300/300 [01:47<00:00,  2.80it/s, acc=97, cost=0.00235]  \n",
      "W0816 15:28:35.363878 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f0455d7deb8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:28:35.471002 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f044b3bf198>: 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:46<00:00,  2.82it/s, acc=96.9, cost=0.00305]\n",
      "W0816 15:30:22.970038 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f044b349f60>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:30:23.075726 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f03f03e0e10>: 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:47<00:00,  2.77it/s, acc=95.1, cost=0.00633]\n",
      "W0816 15:32:11.926008 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f03f043bfd0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:32:12.031505 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f03a4bb2a58>: 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:47<00:00,  2.86it/s, acc=95.9, cost=0.00422]\n",
      "W0816 15:34:00.252120 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f03f0194f60>: 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": [
      "W0816 15:34:00.478516 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f044c079320>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "train loop: 100%|██████████| 300/300 [01:48<00:00,  2.75it/s, acc=96.3, cost=0.00351]\n",
      "W0816 15:35:49.588577 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f03965d9940>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:35:49.693055 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f0393f722e8>: 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:47<00:00,  2.79it/s, acc=96.2, cost=0.00384]\n",
      "W0816 15:37:38.517486 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f0393f489e8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:37:38.625684 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f039189c940>: 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:47<00:00,  2.79it/s, acc=95.6, cost=0.00472]\n",
      "W0816 15:39:27.256033 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f0391929fd0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:39:27.363451 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f038f1f4d68>: 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:47<00:00,  2.78it/s, acc=96.1, cost=0.00394]\n",
      "W0816 15:41:15.619689 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f038f286940>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:41:15.724680 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f038cb1fda0>: 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:47<00:00,  2.82it/s, acc=97.3, cost=0.00223]\n",
      "W0816 15:43:04.145420 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f038d74f630>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "W0816 15:43:04.251741 139658996016960 rnn_cell_impl.py:893] <tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f0388c03d68>: 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:45<00:00,  2.82it/s, acc=96.6, cost=0.00292]\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
}