diff --git a/README.md b/README.md
index 890454f..901a04b 100755
--- a/README.md
+++ b/README.md
@@ -49,6 +49,7 @@
  15. GRU Seq2seq VAE
  16. Attention-is-all-you-Need
  17. CNN-Seq2seq
+ 18. Dilated-CNN-Seq2seq
 
 **Bonus**
 
@@ -217,74 +218,78 @@ I will cut the dataset to train and test datasets,
 
 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.
 
-1. LSTM, 95.693%
+1. LSTM, accuracy 95.693%, time taken for 1 epoch 01:09
 
 <img src="output/lstm.png" width="70%" align="">
 
-2. LSTM Bidirectional, 93.8%
+2. LSTM Bidirectional, accuracy 93.8%, time taken for 1 epoch 01:40
 
 <img src="output/bidirectional-lstm.png" width="70%" align="">
 
-3. LSTM 2-Path, 94.63%
+3. LSTM 2-Path, accuracy 94.63%, time taken for 1 epoch 01:39
 
 <img src="output/lstm-2path.png" width="70%" align="">
 
-4. GRU, 94.63%
+4. GRU, accuracy 94.63%, time taken for 1 epoch 02:10
 
 <img src="output/gru.png" width="70%" align="">
 
-5. GRU Bidirectional, 92.5673%
+5. GRU Bidirectional, accuracy 92.5673%, time taken for 1 epoch 01:40
 
 <img src="output/bidirectional-gru.png" width="70%" align="">
 
-6. GRU 2-Path, 93.2117%
+6. GRU 2-Path, accuracy 93.2117%, time taken for 1 epoch 01:39
 
 <img src="output/gru-2path.png" width="70%" align="">
 
-7. Vanilla, 91.4686%
+7. Vanilla, accuracy 91.4686%, time taken for 1 epoch 00:52
 
 <img src="output/vanilla.png" width="70%" align="">
 
-8. Vanilla Bidirectional, 88.9927%
+8. Vanilla Bidirectional, accuracy 88.9927%, time taken for 1 epoch 01:06
 
 <img src="output/bidirectional-vanilla.png" width="70%" align="">
 
-9. Vanilla 2-Path, 91.5406%
+9. Vanilla 2-Path, accuracy 91.5406%, time taken for 1 epoch 01:08
 
 <img src="output/vanilla-2path.png" width="70%" align="">
 
-10. LSTM Seq2seq, 94.9817%
+10. LSTM Seq2seq, accuracy 94.9817%, time taken for 1 epoch 01:36
 
 <img src="output/lstm-seq2seq.png" width="70%" align="">
 
-11. LSTM Bidirectional Seq2seq, 94.517%
+11. LSTM Bidirectional Seq2seq, accuracy 94.517%, time taken for 1 epoch 02:30
 
 <img src="output/bidirectional-lstm-seq2seq.png" width="70%" align="">
 
-12. LSTM Seq2seq VAE, 95.4190%
+12. LSTM Seq2seq VAE, accuracy 95.4190%, time taken for 1 epoch 01:48
 
 <img src="output/lstm-seq2seq-vae.png" width="70%" align="">
 
-13. GRU Seq2seq, 90.8854%
+13. GRU Seq2seq, accuracy 90.8854%, time taken for 1 epoch 01:34
 
 <img src="output/gru-seq2seq.png" width="70%" align="">
 
-14. GRU Bidirectional Seq2seq, 67.9915%
+14. GRU Bidirectional Seq2seq, accuracy 67.9915%, time taken for 1 epoch 02:30
 
 <img src="output/bidirectional-gru-seq2seq.png" width="70%" align="">
 
-15. GRU Seq2seq VAE, 89.1321%
+15. GRU Seq2seq VAE, accuracy 89.1321%, time taken for 1 epoch 01:48
 
 <img src="output/gru-seq2seq-vae.png" width="70%" align="">
 
-16. Attention-is-all-you-Need, 94.2482%
+16. Attention-is-all-you-Need, accuracy 94.2482%, time taken for 1 epoch 01:41
 
 <img src="output/attention-is-all-you-need.png" width="70%" align="">
 
-17. CNN-Seq2seq, 90.74%
+17. CNN-Seq2seq, accuracy 90.74%, time taken for 1 epoch 00:43
 
 <img src="output/cnn-seq2seq.png" width="70%" align="">
 
+18. Dilated-CNN-Seq2seq, accuracy 95.86%, time taken for 1 epoch 00:14
+
+<img src="output/dilated-cnn-seq2seq.png" width="70%" align="">
+
 **Bonus**
 
 1. How to forecast,
diff --git a/deep-learning/18.dilated-cnn-seq2seq.ipynb b/deep-learning/18.dilated-cnn-seq2seq.ipynb
new file mode 100644
index 0000000..897065e
--- /dev/null
+++ b/deep-learning/18.dilated-cnn-seq2seq.ipynb
@@ -0,0 +1,706 @@
+{
+ "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 position_encoding(inputs):\n",
+    "    T = tf.shape(inputs)[1]\n",
+    "    repr_dim = inputs.get_shape()[-1].value\n",
+    "    pos = tf.reshape(tf.range(0.0, tf.to_float(T), dtype=tf.float32), [-1, 1])\n",
+    "    i = np.arange(0, repr_dim, 2, np.float32)\n",
+    "    denom = np.reshape(np.power(10000.0, i / repr_dim), [1, -1])\n",
+    "    enc = tf.expand_dims(tf.concat([tf.sin(pos / denom), tf.cos(pos / denom)], 1), 0)\n",
+    "    return tf.tile(enc, [tf.shape(inputs)[0], 1, 1])\n",
+    "\n",
+    "def layer_norm(inputs, epsilon=1e-8):\n",
+    "    mean, variance = tf.nn.moments(inputs, [-1], keep_dims=True)\n",
+    "    normalized = (inputs - mean) / (tf.sqrt(variance + epsilon))\n",
+    "    params_shape = inputs.get_shape()[-1:]\n",
+    "    gamma = tf.get_variable('gamma', params_shape, tf.float32, tf.ones_initializer())\n",
+    "    beta = tf.get_variable('beta', params_shape, tf.float32, tf.zeros_initializer())\n",
+    "    return gamma * normalized + beta\n",
+    "\n",
+    "def cnn_block(x, dilation_rate, pad_sz, hidden_dim, kernel_size):\n",
+    "    x = layer_norm(x)\n",
+    "    pad = tf.zeros([tf.shape(x)[0], pad_sz, hidden_dim])\n",
+    "    x =  tf.layers.conv1d(inputs = tf.concat([pad, x, pad], 1),\n",
+    "                          filters = hidden_dim,\n",
+    "                          kernel_size = kernel_size,\n",
+    "                          dilation_rate = dilation_rate)\n",
+    "    x = x[:, :-pad_sz, :]\n",
+    "    x = tf.nn.relu(x)\n",
+    "    return x\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",
+    "        encoder_embedded += position_encoding(encoder_embedded)\n",
+    "        \n",
+    "        e = tf.identity(encoder_embedded)\n",
+    "        for i in range(num_layers): \n",
+    "            dilation_rate = 2 ** i\n",
+    "            pad_sz = (kernel_size - 1) * dilation_rate \n",
+    "            with tf.variable_scope('block_%d'%i):\n",
+    "                encoder_embedded += cnn_block(encoder_embedded, dilation_rate, \n",
+    "                                              pad_sz, size_layer, kernel_size)\n",
+    "                \n",
+    "        encoder_output, output_memory = encoder_embedded, encoder_embedded + e\n",
+    "        g = tf.identity(encoder_embedded)\n",
+    "\n",
+    "        for i in range(num_layers):\n",
+    "            dilation_rate = 2 ** i\n",
+    "            pad_sz = (kernel_size - 1) * dilation_rate\n",
+    "            with tf.variable_scope('decode_%d'%i):\n",
+    "                attn_res = h = cnn_block(encoder_embedded, dilation_rate, \n",
+    "                                         pad_sz, size_layer, kernel_size)\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.8\n",
+    "future_day = test_size\n",
+    "learning_rate = 5e-4"
+   ]
+  },
+  {
+   "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",
+      "W0829 00:04:33.873839 140104212150080 deprecation.py:323] From <ipython-input-6-1aeaade5f897>:44: 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",
+      "W0829 00:04:33.883059 140104212150080 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"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 1\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "W0829 00:04:34.265801 140104212150080 deprecation.py:323] From <ipython-input-6-1aeaade5f897>:4: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use `tf.cast` instead.\n",
+      "W0829 00:04:34.294613 140104212150080 deprecation.py:323] From <ipython-input-6-1aeaade5f897>:24: conv1d (from tensorflow.python.layers.convolutional) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use `tf.keras.layers.Conv1D` instead.\n",
+      "W0829 00:04:36.600379 140104212150080 deprecation.py:506] From <ipython-input-6-1aeaade5f897>:82: 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:14<00:00, 20.69it/s, acc=93, cost=0.0106]   \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 2\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "train loop: 100%|██████████| 300/300 [00:14<00:00, 20.99it/s, acc=97.6, cost=0.00116]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 3\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "train loop: 100%|██████████| 300/300 [00:14<00:00, 20.94it/s, acc=95.2, cost=0.00553]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 4\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "train loop: 100%|██████████| 300/300 [00:14<00:00, 20.97it/s, acc=95.4, cost=0.00442]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 5\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "train loop: 100%|██████████| 300/300 [00:14<00:00, 21.88it/s, acc=95.6, cost=0.00393]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 6\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "train loop: 100%|██████████| 300/300 [00:14<00:00, 21.01it/s, acc=95.3, cost=0.00454]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 7\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "train loop: 100%|██████████| 300/300 [00:14<00:00, 21.05it/s, acc=96.7, cost=0.00229]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 8\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "train loop: 100%|██████████| 300/300 [00:14<00:00, 21.01it/s, acc=97.1, cost=0.00178]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 9\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "train loop: 100%|██████████| 300/300 [00:14<00:00, 20.80it/s, acc=95.3, cost=0.00492]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "simulation 10\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "train loop: 100%|██████████| 300/300 [00:14<00:00, 20.94it/s, acc=90.6, cost=0.0192] \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
+}
diff --git a/output/dilated-cnn-seq2seq.png b/output/dilated-cnn-seq2seq.png
new file mode 100644
index 0000000..24c0dcb
Binary files /dev/null and b/output/dilated-cnn-seq2seq.png differ