1.lstm.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import warnings\n",
    "\n",
    "if not sys.warnoptions:\n",
    "    warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.version.VERSION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('GOOG-year.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": 6,
     "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": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((252, 7), (222, 1), (30, 1))"
      ]
     },
     "execution_count": 7,
     "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": 22,
   "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.keras.layers.LSTM(size_layer, stateful=False, return_state=True)\n",
    "\n",
    "        rnn_cells = tf.keras.layers.StackedRNNCells([lstm_cell(size_layer) for _ in range(num_layers)])\n",
    "        self.X = tf.placeholder(tf.float32, (None, None, size))\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "        drop = tf.keras.layers.Dropout(rate=forget_bias)\n",
    "        self.hidden_layer = tf.placeholder(tf.float32, (None, num_layers * 2 * size_layer))\n",
    "        self.outputs, self.last_state = tf.nn.dynamic_rnn(\n",
    "            rnn_cells, self.X, initial_state=self.hidden_layer, dtype=tf.float32\n",
    "        )\n",
    "        self.logits = tf.keras.layers.Dense(output_size)(self.outputs[:, -1, :])\n",
    "        self.cost = tf.reduce_mean(tf.square(self.Y - self.logits))\n",
    "        self.optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate).minimize(self.cost)\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": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forecast():\n",
    "    tf.compat.v1.reset_default_graph()\n",
    "    modelnn = Model(learning_rate, num_layers, df_log.shape[1], size_layer, df_log.shape[1], dropout_rate)\n",
    "    sess = tf.compat.v1.InteractiveSession()\n",
    "    sess.run(tf.compat.v1.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(df_train.iloc[k:index, :].values, axis=0)\n",
    "            batch_y = df_train.iloc[k + 1 : index + 1, :].values\n",
    "            logits, last_state, _, loss = sess.run(\n",
    "                [modelnn.logits, modelnn.last_state, modelnn.optimizer, modelnn.cost],\n",
    "                feed_dict={\n",
    "                    modelnn.X: batch_x,\n",
    "                    modelnn.Y: batch_y,\n",
    "                    modelnn.hidden_layer: init_value,\n",
    "                },\n",
    "            )\n",
    "            init_value = last_state\n",
    "            total_loss.append(loss)\n",
    "            total_acc.append(calculate_accuracy(batch_y[:, 0], logits[:, 0]))\n",
    "        pbar.set_postfix(cost=np.mean(total_loss), acc=np.mean(total_acc))\n",
    "\n",
    "    future_day = test_size\n",
    "\n",
    "    output_predict = np.zeros((df_train.shape[0] + future_day, df_train.shape[1]))\n",
    "    output_predict[0] = df_train.iloc[0]\n",
    "    upper_b = (df_train.shape[0] // timestamp) * timestamp\n",
    "    init_value = np.zeros((1, num_layers * 2 * size_layer))\n",
    "\n",
    "    for k in range(0, (df_train.shape[0] // timestamp) * timestamp, timestamp):\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict={\n",
    "                modelnn.X: np.expand_dims(df_train.iloc[k : k + timestamp], axis=0),\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": 16,
   "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.LSTMCell(size_layer, state_is_tuple = False)\n",
    "\n",
    "        rnn_cells = tf.nn.rnn_cell.MultiRNNCell(\n",
    "            [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "            state_is_tuple = False,\n",
    "        )\n",
    "        self.X = tf.placeholder(tf.float32, (None, None, size))\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "        drop = tf.contrib.rnn.DropoutWrapper(\n",
    "            rnn_cells, output_keep_prob = forget_bias\n",
    "        )\n",
    "        self.hidden_layer = tf.placeholder(\n",
    "            tf.float32, (None, num_layers * 2 * size_layer)\n",
    "        )\n",
    "        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": 12,
   "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.keras.layers.LSTM(size_layer, stateful=False, return_state=True)\n",
    "\n",
    "        rnn_cells = tf.keras.layers.StackedRNNCells([lstm_cell(size_layer) for _ in range(num_layers)]),\n",
    "        \n",
    "        self.X = tf.placeholder(tf.float32, (None, None, size))\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "        drop = tf.contrib.rnn.DropoutWrapper(\n",
    "            rnn_cells, output_keep_prob = forget_bias\n",
    "        )\n",
    "        self.hidden_layer = tf.placeholder(\n",
    "            tf.float32, (None, num_layers * 2 * size_layer)\n",
    "        )\n",
    "        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": 26,
   "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\n",
    "simulation_size =10 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = []\n",
    "simulation_size =10 \n",
    "for i in range(simulation_size):\n",
    "    print('simulation %d'%(i + 1))\n",
    "    results.append(forecast())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Simulation 1\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "All cells must have a `state_size` attribute. Received cell without a `state_size`: <keras.src.layers.rnn.lstm.LSTM object at 0x0000023AB4FF7190>",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\ediso\\OneDrive\\Escritorio\\Econometria2\\Deep-Learning-Wk\\1.lstm.ipynb Cell 13\u001b[0m line \u001b[0;36m1\n\u001b[0;32m    <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=139'>140</a>\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(simulation_size):\n\u001b[0;32m    <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=140'>141</a>\u001b[0m     \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mSimulation \u001b[39m\u001b[39m%d\u001b[39;00m\u001b[39m'\u001b[39m \u001b[39m%\u001b[39m (i \u001b[39m+\u001b[39m \u001b[39m1\u001b[39m))\n\u001b[1;32m--> <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=141'>142</a>\u001b[0m     results\u001b[39m.\u001b[39mappend(forecast())\n",
      "\u001b[1;32mc:\\Users\\ediso\\OneDrive\\Escritorio\\Econometria2\\Deep-Learning-Wk\\1.lstm.ipynb Cell 13\u001b[0m line \u001b[0;36m4\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=46'>47</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mforecast\u001b[39m():\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=47'>48</a>\u001b[0m     tf\u001b[39m.\u001b[39mcompat\u001b[39m.\u001b[39mv1\u001b[39m.\u001b[39mreset_default_graph()\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=48'>49</a>\u001b[0m     modelnn \u001b[39m=\u001b[39m Model(learning_rate, num_layers, df_log\u001b[39m.\u001b[39;49mshape[\u001b[39m1\u001b[39;49m], size_layer, df_log\u001b[39m.\u001b[39;49mshape[\u001b[39m1\u001b[39;49m], dropout_rate)\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=49'>50</a>\u001b[0m     sess \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mcompat\u001b[39m.\u001b[39mv1\u001b[39m.\u001b[39mInteractiveSession()\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=50'>51</a>\u001b[0m     sess\u001b[39m.\u001b[39mrun(tf\u001b[39m.\u001b[39mcompat\u001b[39m.\u001b[39mv1\u001b[39m.\u001b[39mglobal_variables_initializer())\n",
      "\u001b[1;32mc:\\Users\\ediso\\OneDrive\\Escritorio\\Econometria2\\Deep-Learning-Wk\\1.lstm.ipynb Cell 13\u001b[0m line \u001b[0;36m2\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=16'>17</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mlstm_cell\u001b[39m(size_layer):\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=17'>18</a>\u001b[0m     \u001b[39mreturn\u001b[39;00m tf\u001b[39m.\u001b[39mkeras\u001b[39m.\u001b[39mlayers\u001b[39m.\u001b[39mLSTM(size_layer, stateful\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m, return_state\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=19'>20</a>\u001b[0m rnn_cells \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39;49mkeras\u001b[39m.\u001b[39;49mlayers\u001b[39m.\u001b[39;49mStackedRNNCells([lstm_cell(size_layer) \u001b[39mfor\u001b[39;49;00m _ \u001b[39min\u001b[39;49;00m \u001b[39mrange\u001b[39;49m(num_layers)])\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=20'>21</a>\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mX \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mplaceholder(tf\u001b[39m.\u001b[39mfloat32, (\u001b[39mNone\u001b[39;00m, \u001b[39mNone\u001b[39;00m, size))\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/ediso/OneDrive/Escritorio/Econometria2/Deep-Learning-Wk/1.lstm.ipynb#X23sZmlsZQ%3D%3D?line=21'>22</a>\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mY \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mplaceholder(tf\u001b[39m.\u001b[39mfloat32, (\u001b[39mNone\u001b[39;00m, output_size))\n",
      "File \u001b[1;32mc:\\Users\\ediso\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\keras\\src\\layers\\rnn\\stacked_rnn_cells.py:68\u001b[0m, in \u001b[0;36mStackedRNNCells.__init__\u001b[1;34m(self, cells, **kwargs)\u001b[0m\n\u001b[0;32m     63\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m     64\u001b[0m             \u001b[39m\"\u001b[39m\u001b[39mAll cells must have a `call` method. \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m     65\u001b[0m             \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mReceived cell without a `call` method: \u001b[39m\u001b[39m{\u001b[39;00mcell\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[0;32m     66\u001b[0m         )\n\u001b[0;32m     67\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mstate_size\u001b[39m\u001b[39m\"\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m \u001b[39mdir\u001b[39m(cell):\n\u001b[1;32m---> 68\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m     69\u001b[0m             \u001b[39m\"\u001b[39m\u001b[39mAll cells must have a `state_size` attribute. \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m     70\u001b[0m             \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mReceived cell without a `state_size`: \u001b[39m\u001b[39m{\u001b[39;00mcell\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[0;32m     71\u001b[0m         )\n\u001b[0;32m     72\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcells \u001b[39m=\u001b[39m cells\n\u001b[0;32m     73\u001b[0m \u001b[39m# reverse_state_order determines whether the state size will be in a\u001b[39;00m\n\u001b[0;32m     74\u001b[0m \u001b[39m# reverse order of the cells' state. User might want to set this to True\u001b[39;00m\n\u001b[0;32m     75\u001b[0m \u001b[39m# to keep the existing behavior. This is only useful when use\u001b[39;00m\n\u001b[0;32m     76\u001b[0m \u001b[39m# RNN(return_state=True) since the state will be returned as the same\u001b[39;00m\n\u001b[0;32m     77\u001b[0m \u001b[39m# order of state_size.\u001b[39;00m\n",
      "\u001b[1;31mValueError\u001b[0m: All cells must have a `state_size` attribute. Received cell without a `state_size`: <keras.src.layers.rnn.lstm.LSTM object at 0x0000023AB4FF7190>"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "from datetime import timedelta\n",
    "\n",
    "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.keras.layers.LSTM(size_layer, stateful=False, return_state=True)\n",
    "\n",
    "        rnn_cells = tf.keras.layers.StackedRNNCells([lstm_cell(size_layer) for _ in range(num_layers)])\n",
    "        self.X = tf.placeholder(tf.float32, (None, None, size))\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "        drop = tf.keras.layers.Dropout(rate=forget_bias)\n",
    "        self.hidden_layer = tf.placeholder(tf.float32, (None, num_layers * 2 * size_layer))\n",
    "        self.outputs, self.last_state = tf.nn.dynamic_rnn(\n",
    "            rnn_cells, self.X, initial_state=self.hidden_layer, dtype=tf.float32\n",
    "        )\n",
    "        self.logits = tf.keras.layers.Dense(output_size)(self.outputs[:, -1, :])\n",
    "        self.cost = tf.reduce_mean(tf.square(self.Y - self.logits))\n",
    "        self.optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate).minimize(self.cost)\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\n",
    "\n",
    "def forecast():\n",
    "    tf.compat.v1.reset_default_graph()\n",
    "    modelnn = Model(learning_rate, num_layers, df_log.shape[1], size_layer, df_log.shape[1], dropout_rate)\n",
    "    sess = tf.compat.v1.InteractiveSession()\n",
    "    sess.run(tf.compat.v1.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(df_train.iloc[k:index, :].values, axis=0)\n",
    "            batch_y = df_train.iloc[k + 1 : index + 1, :].values\n",
    "            logits, last_state, _, loss = sess.run(\n",
    "                [modelnn.logits, modelnn.last_state, modelnn.optimizer, modelnn.cost],\n",
    "                feed_dict={\n",
    "                    modelnn.X: batch_x,\n",
    "                    modelnn.Y: batch_y,\n",
    "                    modelnn.hidden_layer: init_value,\n",
    "                },\n",
    "            )\n",
    "            init_value = last_state\n",
    "            total_loss.append(loss)\n",
    "            total_acc.append(calculate_accuracy(batch_y[:, 0], logits[:, 0]))\n",
    "        pbar.set_postfix(cost=np.mean(total_loss), acc=np.mean(total_acc))\n",
    "\n",
    "    future_day = test_size\n",
    "\n",
    "    output_predict = np.zeros((df_train.shape[0] + future_day, df_train.shape[1]))\n",
    "    output_predict[0] = df_train.iloc[0]\n",
    "    upper_b = (df_train.shape[0] // timestamp) * timestamp\n",
    "    init_value = np.zeros((1, num_layers * 2 * size_layer))\n",
    "\n",
    "    for k in range(0, (df_train.shape[0] // timestamp) * timestamp, timestamp):\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict={\n",
    "                modelnn.X: np.expand_dims(df_train.iloc[k : k + timestamp], axis=0),\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:]\n",
    "\n",
    "# Set your parameters\n",
    "learning_rate = 0.001\n",
    "num_layers = 2\n",
    "size_layer = 128\n",
    "output_size = 1\n",
    "forget_bias = 0.1\n",
    "epoch = 100\n",
    "timestamp = 5\n",
    "test_size = 30\n",
    "dropout_rate = 0.8\n",
    "\n",
    "# Your data preprocessing and df_train creation here...\n",
    "\n",
    "simulation_size = 10\n",
    "results = []\n",
    "for i in range(simulation_size):\n",
    "    print('Simulation %d' % (i + 1))\n",
    "    results.append(forecast())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\ediso\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\numpy\\core\\fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n",
      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
      "c:\\Users\\ediso\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\numpy\\core\\_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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()"
   ]
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}