Quant_Code/5.课程代码/4.Stock-Prediction-Models/使用文档/Stock-Prediction-Models-master/deep-learning/14.bidirectional-gru-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": 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.GRUCell(size_layer)\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 * size_layer)\n",
    "        )\n",
    "        self.forward_hidden_layer = tf.placeholder(\n",
    "            tf.float32, shape = (None, num_layers * size_layer)\n",
    "        )\n",
    "        _, 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",
    "        \n",
    "        with tf.variable_scope('decoder', reuse = False):\n",
    "            backward_rnn_cells_decoder = 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_decoder = tf.nn.rnn_cell.MultiRNNCell(\n",
    "                [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "                state_is_tuple = False,\n",
    "            )\n",
    "            drop_backward_decoder = tf.contrib.rnn.DropoutWrapper(\n",
    "            backward_rnn_cells_decoder, output_keep_prob = forget_bias\n",
    "            )\n",
    "            forward_backward_decoder = tf.contrib.rnn.DropoutWrapper(\n",
    "                forward_rnn_cells_decoder, output_keep_prob = forget_bias\n",
    "            )\n",
    "            self.outputs, self.last_state = tf.nn.bidirectional_dynamic_rnn(\n",
    "                forward_backward_decoder, drop_backward_decoder, self.X, \n",
    "                initial_state_fw = last_state[0],\n",
    "                initial_state_bw = last_state[1],\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 * size_layer))\n",
    "        init_value_backward = np.zeros((1, num_layers * 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 * size_layer))\n",
    "    init_value_backward = np.zeros((1, num_layers * 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",
      "W0816 18:33:46.362064 140384958228288 deprecation.py:323] From <ipython-input-6-2500790da2db>:12: GRUCell.__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.GRUCell, and will be replaced by that in Tensorflow 2.0.\n",
      "W0816 18:33:46.364130 140384958228288 deprecation.py:323] From <ipython-input-6-2500790da2db>:16: MultiRNNCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.StackedRNNCells, and will be replaced by that in Tensorflow 2.0.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0816 18:33:46.687459 140384958228288 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 18:33:46.692470 140384958228288 deprecation.py:323] From <ipython-input-6-2500790da2db>: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",
      "W0816 18:33:46.693083 140384958228288 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",
      "W0816 18:33:46.884588 140384958228288 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 18:33:46.891244 140384958228288 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:564: calling Constant.__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 18:33:46.900250 140384958228288 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:574: 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 18:33:47.374557 140384958228288 deprecation.py:323] From <ipython-input-6-2500790da2db>:67: 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 [02:28<00:00,  2.02it/s, acc=97.7, cost=0.00125] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:26<00:00,  2.05it/s, acc=98.3, cost=0.000708]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:29<00:00,  2.01it/s, acc=98.1, cost=0.000848]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:27<00:00,  2.03it/s, acc=98.5, cost=0.000662]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:30<00:00,  2.01it/s, acc=97.4, cost=0.0017]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:29<00:00,  2.01it/s, acc=97.7, cost=0.00127] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:30<00:00,  1.99it/s, acc=98.3, cost=0.000625]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:29<00:00,  2.01it/s, acc=98.2, cost=0.000883]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:29<00:00,  2.01it/s, acc=98.5, cost=0.000547]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:29<00:00,  2.00it/s, acc=96.9, cost=0.00229] \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
}