DA_RNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch.nn as nn\n",
    "from torch import optim\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torch.utils.data import Dataset, DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AttentionEncoder(nn.Module):\n",
    "    def __init__(self, input_size, T, hidden_size, dropout):\n",
    "        super(AttentionEncoder, self).__init__()\n",
    "        self.input_size = input_size\n",
    "        self.T = T\n",
    "        self.hidden_size = hidden_size\n",
    "        self.dropout = dropout\n",
    "        \n",
    "        self.lstm = nn.LSTM(self.input_size, self.hidden_size, dropout = self.dropout)\n",
    "        # define attention layer\n",
    "        self.linear = nn.Linear(self.T + self.hidden_size * 2, self.T, False)\n",
    "        self.linear2 = nn.Linear(self.T, 1, False)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # note that input x has dimension of batch * T * input_size, and hidden is batch * hidden_size\n",
    "        batch_size = x.shape[0]\n",
    "        h = self.init_state(batch_size, self.hidden_size)\n",
    "        c = self.init_state(batch_size, self.hidden_size)\n",
    "        h_out=torch.zeros(self.T, batch_size, self.hidden_size, device = device)\n",
    "        \n",
    "        for i in range(self.T):\n",
    "            # first calculate input attention\n",
    "            concat_hc = torch.cat((h, c), 2).permute(1,0,2).repeat(1, self.input_size, 1)\n",
    "            # concat_hc has a size of batch_size * input_size * 2 hidden_size\n",
    "            out = self.linear(torch.cat((concat_hc, x.permute(0, 2, 1)), 2))\n",
    "            # out has a dimension of (batch_size*input_size) * T\n",
    "            weight = self.linear2(torch.tanh(out)).view(batch_size, self.input_size)\n",
    "            weight = torch.softmax(weight, 1)\n",
    "            # weight has a size of batch * input_size\n",
    "            \n",
    "            # update h and c\n",
    "            _, new_state = self.lstm((x[:,i,:] * weight).unsqueeze(0), (h, c))\n",
    "            h, c = new_state\n",
    "            h_out[i] = h[0]\n",
    "        return h_out\n",
    "    def init_state(self, batch_size, hidden_size):\n",
    "        return torch.zeros(1, batch_size, hidden_size, device=device)\n",
    "    def init_weight(self, T, batch_size, input_size):\n",
    "        return torch.zeros(1, T, batch_size, input_size, device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AttentionDecoder(nn.Module):\n",
    "    def __init__(self, input_size, T, hidden_size, dropout):\n",
    "        super(AttentionDecoder, self).__init__()\n",
    "        # input size = 1 + m, here m is h state dimension\n",
    "        self.input_size = input_size\n",
    "        self.T = T\n",
    "        self.hidden_size = hidden_size\n",
    "        self.dropout = dropout\n",
    "        \n",
    "        # use nn.ModuleList for customized sequential layers\n",
    "        self.lstm = nn.LSTM(1, self.hidden_size, dropout = self.dropout)\n",
    "        # define attention layers which are linear of tanh layers\n",
    "        self.linear = nn.Linear(self.input_size - 1 + self.hidden_size * 2, self.input_size - 1, False)\n",
    "        self.v = nn.Linear(self.input_size - 1, 1, False)\n",
    "        self.linear2 = nn.Linear(self.input_size, 1)\n",
    "        self.linear3 = nn.Linear(self.hidden_size + self.input_size - 1, self.hidden_size)\n",
    "        self.linear4 = nn.Linear(self.hidden_size, 1)\n",
    "    def forward(self, y, h):\n",
    "        batch_size = y.shape[0]\n",
    "        d=self.init_state(batch_size,self.hidden_size)\n",
    "        s=self.init_state(batch_size,self.hidden_size)\n",
    "        # note that input y: batch * T * 1, h: T * batch * m, hidden state d: batch * hidden_size\n",
    "        for i in range(self.T):\n",
    "            # first calculate temporal attention on h from encoder\n",
    "            concat_ds = torch.cat((d, s), 2).permute(1, 0, 2).repeat(1, self.T, 1)\n",
    "            out = self.linear(torch.cat((concat_ds, h.permute(1, 0, 2)), 2))\n",
    "            weight = self.v(torch.tanh(out)).view(batch_size, self.T)\n",
    "            weight = torch.softmax(weight, 1)\n",
    "            weight = weight.unsqueeze(1)\n",
    "            # new h after temporal attention, batch_size * hidden\n",
    "            new_h = torch.bmm(weight, h.permute(1, 0, 2)).squeeze(1)\n",
    "            # update d and s\n",
    "            _, new_state = self.lstm((self.linear2(torch.cat((y[:,i,:], new_h), 1))).unsqueeze(0), (d, s))\n",
    "            d, s = new_state\n",
    "    \n",
    "        y_out = self.linear4(self.linear3(torch.cat((d.squeeze(0), new_h), 1)))\n",
    "        return y_out\n",
    "    def init_state(self, batch_size, hidden_size):\n",
    "        return torch.zeros(1, batch_size, hidden_size, device=device)\n",
    "    def init_weight(self, T, batch_size):\n",
    "        return torch.zeros(1, batch_size, T, device=device)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Train(Encoder, Decoder, Train_generator, Eval_X, Eval_Y, config, optimizer, criterion, print_num, EarlyStopping=None):\n",
    "    scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer=optimizer, gamma=0.95)\n",
    "    Train_loss, Val_loss = [], []\n",
    "    Eval_X1, Eval_X2 = torch.split(Eval_X, [Eval_X.shape[2] - 1, 1], dim=2)\n",
    "    if EarlyStopping:\n",
    "        count = 0\n",
    "        best_loss = float('inf')\n",
    "    for epoch in range(config.epoch):\n",
    "        tic = time.time()\n",
    "        # Training\n",
    "        num = 0\n",
    "        for x, y in Train_generator:\n",
    "            x1, x2 = torch.split(x, [x.shape[2] - 1, 1], dim=2)\n",
    "            optimizer.zero_grad()\n",
    "            y_pred = Decoder(x2, Encoder(x1))\n",
    "            loss = criterion(y_pred, y)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            if num%print_num == 0:\n",
    "                print(loss)\n",
    "            num += 1\n",
    "        Train_loss.append(loss)\n",
    "        # Validation\n",
    "        with torch.no_grad():\n",
    "            y_pred = Decoder(Eval_X2, Encoder(Eval_X1))\n",
    "        Val_loss.append(criterion(y_pred, Eval_Y))\n",
    "        print('Epoch = %d, Time elapsed = %d s, Train loss = %f, Val loss = %f' \n",
    "              % (epoch + 1, time.time() - tic, Train_loss[-1], Val_loss[-1]))\n",
    "        if EarlyStopping:\n",
    "            if Val_loss[-1] < best_loss:\n",
    "                best_loss = Val_loss[-1]\n",
    "                count = 0\n",
    "            elif count >= EarlyStopping:\n",
    "                break\n",
    "            else:\n",
    "                count += 1\n",
    "        scheduler.step()\n",
    "    return Train_loss, Val_loss\n",
    "\n",
    "def predict(Encoder, Decoder, X):\n",
    "    X1, X2 = torch.split(X, [X.shape[2] - 1, 1], dim=2)\n",
    "    with torch.no_grad():\n",
    "        y_pred = Decoder(X2, Encoder(X1))\n",
    "    return y_pred     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class parameter:\n",
    "    T_grid = [10]\n",
    "    m_grid = [128]\n",
    "    batch_size = 256\n",
    "    epoch = 50\n",
    "    learning_rate = 0.001\n",
    "    Test_num = 2700\n",
    "    print_num = 50\n",
    "    dropout = 0\n",
    "config = parameter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40560, 82)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "data =  pd.read_csv('./nasdaq100/small/nasdaq100_padding.csv').values\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([40560, 82])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "percentage = False\n",
    "if percentage:\n",
    "    for i in range(data.shape[0] - 1, 0, -1):\n",
    "        data[i] = (data[i] - data[i-1])/data[i-1]\n",
    "    data = data[1:]\n",
    "scale = StandardScaler().fit(data)\n",
    "data = scale.transform(data)\n",
    "data = torch.from_numpy(data).float()\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.7657, grad_fn=<MseLossBackward>)\n",
      "tensor(0.6958, grad_fn=<MseLossBackward>)\n",
      "tensor(0.2794, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0164, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0072, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0036, grad_fn=<MseLossBackward>)\n",
      "Epoch = 1, Time elapsed = 88 s, Train loss = 0.003068, Val loss = 0.004075\n",
      "tensor(0.0032, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0031, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0088, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0037, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0041, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0023, grad_fn=<MseLossBackward>)\n",
      "Epoch = 2, Time elapsed = 89 s, Train loss = 0.005188, Val loss = 0.004405\n",
      "tensor(0.0041, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0037, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0028, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0034, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0054, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0033, grad_fn=<MseLossBackward>)\n",
      "Epoch = 3, Time elapsed = 90 s, Train loss = 0.002083, Val loss = 0.004317\n",
      "tensor(0.0047, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0048, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0040, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0041, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0021, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0028, grad_fn=<MseLossBackward>)\n",
      "Epoch = 4, Time elapsed = 90 s, Train loss = 0.015843, Val loss = 0.004095\n",
      "tensor(0.0049, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0027, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0035, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0020, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0024, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0023, grad_fn=<MseLossBackward>)\n",
      "Epoch = 5, Time elapsed = 90 s, Train loss = 0.001843, Val loss = 0.003174\n",
      "tensor(0.0028, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0026, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0037, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0059, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0030, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0025, grad_fn=<MseLossBackward>)\n",
      "Epoch = 6, Time elapsed = 95 s, Train loss = 0.006539, Val loss = 0.003262\n",
      "tensor(0.0024, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0028, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0042, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0046, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0030, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0018, grad_fn=<MseLossBackward>)\n",
      "Epoch = 7, Time elapsed = 90 s, Train loss = 0.003660, Val loss = 0.002865\n",
      "tensor(0.0029, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0031, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0037, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0016, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0061, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0027, grad_fn=<MseLossBackward>)\n",
      "Epoch = 8, Time elapsed = 96 s, Train loss = 0.002949, Val loss = 0.002481\n",
      "tensor(0.0023, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0024, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0031, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0027, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0029, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0035, grad_fn=<MseLossBackward>)\n",
      "Epoch = 9, Time elapsed = 99 s, Train loss = 0.002843, Val loss = 0.002465\n",
      "tensor(0.0020, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0025, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0024, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0011, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0017, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0027, grad_fn=<MseLossBackward>)\n",
      "Epoch = 10, Time elapsed = 100 s, Train loss = 0.001914, Val loss = 0.002237\n",
      "tensor(0.0020, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0017, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0023, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0017, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0018, grad_fn=<MseLossBackward>)\n",
      "Epoch = 11, Time elapsed = 90 s, Train loss = 0.000997, Val loss = 0.001818\n",
      "tensor(0.0011, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0017, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0016, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0022, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0020, grad_fn=<MseLossBackward>)\n",
      "Epoch = 12, Time elapsed = 90 s, Train loss = 0.002085, Val loss = 0.001615\n",
      "tensor(0.0017, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0018, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0015, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0023, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0026, grad_fn=<MseLossBackward>)\n",
      "Epoch = 13, Time elapsed = 91 s, Train loss = 0.000786, Val loss = 0.001604\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0021, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0014, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0016, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0016, grad_fn=<MseLossBackward>)\n",
      "Epoch = 14, Time elapsed = 90 s, Train loss = 0.000919, Val loss = 0.001408\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0033, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0019, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0015, grad_fn=<MseLossBackward>)\n",
      "Epoch = 15, Time elapsed = 89 s, Train loss = 0.001165, Val loss = 0.001313\n",
      "tensor(0.0016, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0015, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0015, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0015, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "Epoch = 16, Time elapsed = 100 s, Train loss = 0.001013, Val loss = 0.001221\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0020, grad_fn=<MseLossBackward>)\n",
      "Epoch = 17, Time elapsed = 107 s, Train loss = 0.001078, Val loss = 0.001126\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0014, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0011, grad_fn=<MseLossBackward>)\n",
      "Epoch = 18, Time elapsed = 92 s, Train loss = 0.000776, Val loss = 0.001240\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0066, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0019, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "Epoch = 19, Time elapsed = 98 s, Train loss = 0.000638, Val loss = 0.001068\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0034, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "Epoch = 20, Time elapsed = 100 s, Train loss = 0.000671, Val loss = 0.001012\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0016, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "Epoch = 21, Time elapsed = 125 s, Train loss = 0.000872, Val loss = 0.001005\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0019, grad_fn=<MseLossBackward>)\n",
      "Epoch = 22, Time elapsed = 124 s, Train loss = 0.000542, Val loss = 0.001022\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0017, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0017, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "Epoch = 23, Time elapsed = 117 s, Train loss = 0.020335, Val loss = 0.002010\n",
      "tensor(0.0031, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0015, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0020, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "Epoch = 24, Time elapsed = 105 s, Train loss = 0.000567, Val loss = 0.000902\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0011, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch = 25, Time elapsed = 130 s, Train loss = 0.000927, Val loss = 0.001094\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0020, grad_fn=<MseLossBackward>)\n",
      "Epoch = 26, Time elapsed = 107 s, Train loss = 0.000955, Val loss = 0.000853\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0023, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0014, grad_fn=<MseLossBackward>)\n",
      "Epoch = 27, Time elapsed = 96 s, Train loss = 0.000425, Val loss = 0.000838\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0020, grad_fn=<MseLossBackward>)\n",
      "Epoch = 28, Time elapsed = 91 s, Train loss = 0.000582, Val loss = 0.000840\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0004, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0011, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "Epoch = 29, Time elapsed = 98 s, Train loss = 0.000491, Val loss = 0.000857\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "Epoch = 30, Time elapsed = 98 s, Train loss = 0.000778, Val loss = 0.000869\n",
      "tensor(0.0016, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0017, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "Epoch = 31, Time elapsed = 102 s, Train loss = 0.001434, Val loss = 0.000808\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0011, grad_fn=<MseLossBackward>)\n",
      "Epoch = 32, Time elapsed = 101 s, Train loss = 0.003339, Val loss = 0.000803\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "Epoch = 33, Time elapsed = 101 s, Train loss = 0.000528, Val loss = 0.000869\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0016, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "Epoch = 34, Time elapsed = 100 s, Train loss = 0.000730, Val loss = 0.000763\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0014, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "Epoch = 35, Time elapsed = 98 s, Train loss = 0.000778, Val loss = 0.000756\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "Epoch = 36, Time elapsed = 97 s, Train loss = 0.001216, Val loss = 0.000776\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "Epoch = 37, Time elapsed = 107 s, Train loss = 0.000904, Val loss = 0.000741\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0004, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "Epoch = 38, Time elapsed = 97 s, Train loss = 0.000757, Val loss = 0.000733\n",
      "tensor(0.0013, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0011, grad_fn=<MseLossBackward>)\n",
      "Epoch = 39, Time elapsed = 93 s, Train loss = 0.000530, Val loss = 0.000736\n",
      "tensor(0.0012, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0023, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "Epoch = 40, Time elapsed = 92 s, Train loss = 0.000599, Val loss = 0.000744\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "Epoch = 41, Time elapsed = 94 s, Train loss = 0.000489, Val loss = 0.000787\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0015, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0004, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0004, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "Epoch = 42, Time elapsed = 95 s, Train loss = 0.000430, Val loss = 0.000708\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0018, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0004, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "Epoch = 43, Time elapsed = 96 s, Train loss = 0.000405, Val loss = 0.000703\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0010, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "Epoch = 44, Time elapsed = 100 s, Train loss = 0.000538, Val loss = 0.000697\n",
      "tensor(0.0021, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0004, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "Epoch = 45, Time elapsed = 92 s, Train loss = 0.000733, Val loss = 0.000697\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0009, grad_fn=<MseLossBackward>)\n",
      "Epoch = 46, Time elapsed = 96 s, Train loss = 0.000642, Val loss = 0.000691\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0037, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "Epoch = 47, Time elapsed = 91 s, Train loss = 0.005164, Val loss = 0.000690\n",
      "tensor(0.0008, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0004, grad_fn=<MseLossBackward>)\n",
      "Epoch = 48, Time elapsed = 100 s, Train loss = 0.000300, Val loss = 0.000688\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0033, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0004, grad_fn=<MseLossBackward>)\n",
      "Epoch = 49, Time elapsed = 95 s, Train loss = 0.000401, Val loss = 0.000688\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0007, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0005, grad_fn=<MseLossBackward>)\n",
      "tensor(0.0006, grad_fn=<MseLossBackward>)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.0004, grad_fn=<MseLossBackward>)\n",
      "Epoch = 50, Time elapsed = 93 s, Train loss = 0.000442, Val loss = 0.000719\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "criterion = nn.MSELoss()\n",
    "loss = np.zeros((len(config.T_grid), len(config.m_grid)))\n",
    "N = data.shape[0]\n",
    "Model_list=[]\n",
    "for i, T in enumerate(config.T_grid):\n",
    "    for j, m in enumerate(config.m_grid):\n",
    "        data_Y = data[T:, -1].unsqueeze(1)\n",
    "        data_X = torch.zeros(N - T, T, data.shape[1])\n",
    "        for index in range(N - T):\n",
    "            data_X[index,:,:] = data[index:index + T]\n",
    "        \n",
    "        Train_X, Test_X = data_X.split([N - T - config.Test_num, config.Test_num], dim = 0)\n",
    "        Train_Y, Test_Y = data_Y.split([N - T - config.Test_num, config.Test_num])\n",
    "        Train_X, Eval_X, Train_Y, Eval_Y = train_test_split(Train_X, Train_Y, test_size=0.2)\n",
    "        dataset_Train = torch.utils.data.TensorDataset(Train_X, Train_Y)\n",
    "        Train_generator = DataLoader(dataset_Train, batch_size=config.batch_size, shuffle=True, pin_memory=True)\n",
    "        Encoder = AttentionEncoder(data.shape[1] - 1, T, m, dropout = config.dropout).to(device)\n",
    "        Decoder = AttentionDecoder(1 + m, T, m, dropout = config.dropout).to(device)\n",
    "        optimizer = optim.Adam(list(Encoder.parameters()) + list(Decoder.parameters()), lr=config.learning_rate, weight_decay = 0)\n",
    "        # Training\n",
    "        Train_loss, Val_loss = Train(Encoder, Decoder, Train_generator, Eval_X, Eval_Y, config, optimizer, criterion, 20, 6)\n",
    "        plt.figure()\n",
    "        plt.plot(Train_loss, 'k', Val_loss, 'r--')\n",
    "        plt.show()\n",
    "        Model_list.append([Encoder, Decoder])\n",
    "        # Eval\n",
    "        loss[i][j] = Val_loss[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x254838721d0>,\n",
       " <matplotlib.lines.Line2D at 0x25483872320>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "min_idx = np.argmin(loss)\n",
    "i, j = min_idx//len(config.m_grid), min_idx%len(config.m_grid)\n",
    "T, m = config.T_grid[i], config.m_grid[j]\n",
    "data_Y = data[T:, -1].unsqueeze(1)\n",
    "data_X = torch.zeros(N - T, T, data.shape[1])\n",
    "for index in range(N - T):\n",
    "    data_X[index,:,:] = data[index:index + T]\n",
    "Train_X, Test_X = data_X.split([N - T - config.Test_num, config.Test_num], dim = 0)\n",
    "Train_Y, Test_Y = data_Y.split([N - T - config.Test_num, config.Test_num])\n",
    "\n",
    "# Test\n",
    "Encoder, Decoder = Model_list[min_idx]\n",
    "# first see Train data prediction\n",
    "Train_Y_pred = predict(Encoder, Decoder, Train_X)\n",
    "plt.figure()\n",
    "plt.plot(scale.inverse_transform(Train_Y_pred.cpu().repeat(1,82).numpy())[:,-1],'k',scale.inverse_transform(Train_Y.repeat(1,82).numpy())[:,-1],'r')\n",
    "# see the prediction of new data\n",
    "Test_Y_pred = predict(Encoder, Decoder, Test_X)\n",
    "plt.figure()\n",
    "plt.plot(scale.inverse_transform(Test_Y_pred.cpu().repeat(1,82).numpy())[:,-1],'k',scale.inverse_transform(Test_Y.repeat(1,82).numpy())[:,-1],'r')"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}