{
 "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 hours, 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",
    "        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 * size_layer)\n",
    "        )\n",
    "        self.outputs, self.last_state = tf.nn.dynamic_rnn(\n",
    "            drop, self.X, initial_state = self.hidden_layer, dtype = tf.float32\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": 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 * 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 * 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",
      "W0811 22:46:29.978655 140681713489728 deprecation.py:323] From <ipython-input-6-1b755385b006>: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",
      "W0811 22:46:29.981659 140681713489728 deprecation.py:323] From <ipython-input-6-1b755385b006>: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": [
      "W0811 22:46:31.758260 140681713489728 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",
      "W0811 22:46:31.762153 140681713489728 deprecation.py:323] From <ipython-input-6-1b755385b006>:27: 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",
      "W0811 22:46:32.109607 140681713489728 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",
      "W0811 22:46:32.121295 140681713489728 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",
      "W0811 22:46:32.136707 140681713489728 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",
      "W0811 22:46:32.395149 140681713489728 deprecation.py:323] From <ipython-input-6-1b755385b006>:29: 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:10<00:00,  2.45it/s, acc=97.1, cost=0.00211]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:09<00:00,  2.48it/s, acc=96.2, cost=0.00432]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:08<00:00,  1.88it/s, acc=96.7, cost=0.00239]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:05<00:00,  2.12it/s, acc=96.4, cost=0.00307]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:12<00:00,  1.95it/s, acc=96.9, cost=0.00227]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:15<00:00,  2.64it/s, acc=96.4, cost=0.00318]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:10<00:00,  2.59it/s, acc=96.9, cost=0.00256]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:11<00:00,  2.19it/s, acc=97.2, cost=0.00188]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:14<00:00,  2.48it/s, acc=96.9, cost=0.00226]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [02:06<00:00,  2.48it/s, acc=97.5, cost=0.00167]\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
}