{
 "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": [
    "def encoder_block(inp, n_hidden, filter_size):\n",
    "    inp = tf.expand_dims(inp, 2)\n",
    "    inp = tf.pad(\n",
    "        inp,\n",
    "        [\n",
    "            [0, 0],\n",
    "            [(filter_size[0] - 1) // 2, (filter_size[0] - 1) // 2],\n",
    "            [0, 0],\n",
    "            [0, 0],\n",
    "        ],\n",
    "    )\n",
    "    conv = tf.layers.conv2d(\n",
    "        inp, n_hidden, filter_size, padding = 'VALID', activation = None\n",
    "    )\n",
    "    conv = tf.squeeze(conv, 2)\n",
    "    return conv\n",
    "\n",
    "\n",
    "def decoder_block(inp, n_hidden, filter_size):\n",
    "    inp = tf.expand_dims(inp, 2)\n",
    "    inp = tf.pad(inp, [[0, 0], [filter_size[0] - 1, 0], [0, 0], [0, 0]])\n",
    "    conv = tf.layers.conv2d(\n",
    "        inp, n_hidden, filter_size, padding = 'VALID', activation = None\n",
    "    )\n",
    "    conv = tf.squeeze(conv, 2)\n",
    "    return conv\n",
    "\n",
    "\n",
    "def glu(x):\n",
    "    return tf.multiply(\n",
    "        x[:, :, : tf.shape(x)[2] // 2],\n",
    "        tf.sigmoid(x[:, :, tf.shape(x)[2] // 2 :]),\n",
    "    )\n",
    "\n",
    "\n",
    "def layer(inp, conv_block, kernel_width, n_hidden, residual = None):\n",
    "    z = conv_block(inp, n_hidden, (kernel_width, 1))\n",
    "    return glu(z) + (residual if residual is not None else 0)\n",
    "\n",
    "class Model:\n",
    "    def __init__(\n",
    "        self,\n",
    "        learning_rate,\n",
    "        num_layers,\n",
    "        size,\n",
    "        size_layer,\n",
    "        output_size,\n",
    "        kernel_size = 3,\n",
    "        n_attn_heads = 16,\n",
    "        dropout = 0.9,\n",
    "    ):\n",
    "        self.X = tf.placeholder(tf.float32, (None, None, size))\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "\n",
    "        encoder_embedded = tf.layers.dense(self.X, size_layer)\n",
    "\n",
    "        e = tf.identity(encoder_embedded)\n",
    "        for i in range(num_layers):\n",
    "            z = layer(\n",
    "                encoder_embedded,\n",
    "                encoder_block,\n",
    "                kernel_size,\n",
    "                size_layer * 2,\n",
    "                encoder_embedded,\n",
    "            )\n",
    "            z = tf.nn.dropout(z, keep_prob = dropout)\n",
    "            encoder_embedded = z\n",
    "\n",
    "        encoder_output, output_memory = z, z + e\n",
    "        g = tf.identity(encoder_embedded)\n",
    "\n",
    "        for i in range(num_layers):\n",
    "            attn_res = h = layer(\n",
    "                encoder_embedded,\n",
    "                decoder_block,\n",
    "                kernel_size,\n",
    "                size_layer * 2,\n",
    "                residual = tf.zeros_like(encoder_embedded),\n",
    "            )\n",
    "            C = []\n",
    "            for j in range(n_attn_heads):\n",
    "                h_ = tf.layers.dense(h, size_layer // n_attn_heads)\n",
    "                g_ = tf.layers.dense(g, size_layer // n_attn_heads)\n",
    "                zu_ = tf.layers.dense(\n",
    "                    encoder_output, size_layer // n_attn_heads\n",
    "                )\n",
    "                ze_ = tf.layers.dense(output_memory, size_layer // n_attn_heads)\n",
    "\n",
    "                d = tf.layers.dense(h_, size_layer // n_attn_heads) + g_\n",
    "                dz = tf.matmul(d, tf.transpose(zu_, [0, 2, 1]))\n",
    "                a = tf.nn.softmax(dz)\n",
    "                c_ = tf.matmul(a, ze_)\n",
    "                C.append(c_)\n",
    "\n",
    "            c = tf.concat(C, 2)\n",
    "            h = tf.layers.dense(attn_res + c, size_layer)\n",
    "            h = tf.nn.dropout(h, keep_prob = dropout)\n",
    "            encoder_embedded = h\n",
    "\n",
    "        encoder_embedded = tf.sigmoid(encoder_embedded[-1])\n",
    "        self.logits = tf.layers.dense(encoder_embedded, 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 = test_size\n",
    "epoch = 300\n",
    "dropout_rate = 0.7\n",
    "future_day = test_size\n",
    "learning_rate = 1e-3"
   ]
  },
  {
   "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], \n",
    "        dropout = 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, _, loss = sess.run(\n",
    "                [modelnn.logits, modelnn.optimizer, modelnn.cost],\n",
    "                feed_dict = {modelnn.X: batch_x, modelnn.Y: batch_y},\n",
    "            )        \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",
    "\n",
    "    for k in range(0, (df_train.shape[0] // timestamp) * timestamp, timestamp):\n",
    "        out_logits = sess.run(\n",
    "            modelnn.logits,\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(\n",
    "                    df_train.iloc[k : k + timestamp], axis = 0\n",
    "                )\n",
    "            },\n",
    "        )\n",
    "        output_predict[k + 1 : k + timestamp + 1] = out_logits\n",
    "\n",
    "    if upper_b != df_train.shape[0]:\n",
    "        out_logits = sess.run(\n",
    "            modelnn.logits,\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(df_train.iloc[upper_b:], axis = 0)\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",
    "    for i in range(future_day):\n",
    "        o = output_predict[-future_day - timestamp + i:-future_day + i]\n",
    "        out_logits = sess.run(\n",
    "            modelnn.logits,\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(o, axis = 0)\n",
    "            },\n",
    "        )\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",
      "W0818 16:16:28.504163 139649888855872 deprecation.py:323] From <ipython-input-6-6c0655f4345e>:55: 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",
      "W0818 16:16:28.507718 139649888855872 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",
      "W0818 16:16:28.696973 139649888855872 deprecation.py:323] From <ipython-input-6-6c0655f4345e>:13: conv2d (from tensorflow.python.layers.convolutional) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.keras.layers.Conv2D` instead.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0818 16:16:28.910956 139649888855872 deprecation.py:506] From <ipython-input-6-6c0655f4345e>:66: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  7.09it/s, acc=96.6, cost=0.00251]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  7.08it/s, acc=96.9, cost=0.00232] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  6.99it/s, acc=94.1, cost=0.00764] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  6.98it/s, acc=96.6, cost=0.00273]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  7.02it/s, acc=97.7, cost=0.00113] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  7.06it/s, acc=97.7, cost=0.00117]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  6.98it/s, acc=96.4, cost=0.00286]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  6.97it/s, acc=94.7, cost=0.00573] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  6.94it/s, acc=93.9, cost=0.00807] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [00:43<00:00,  7.05it/s, acc=94.6, cost=0.006]  \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
}