codes/Pytorch_Conv1d_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "542760f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6.0+cpu\n",
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from copy import deepcopy # Add Deepcopy for args\n",
    "\n",
    "import seaborn as sns \n",
    "import matplotlib.pyplot as plt\n",
    "import os, pickle, joblib, argparse\n",
    "\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from statsmodels.tsa.api import SimpleExpSmoothing\n",
    "from sklearn.preprocessing import KBinsDiscretizer\n",
    "\n",
    "# pytorch\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import functional as F\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "import torch.optim as optim\n",
    "from torch.optim.lr_scheduler import _LRScheduler\n",
    " \n",
    "print(torch.__version__)\n",
    "%matplotlib inline\n",
    "%pylab inline\n",
    "pylab.rcParams['figure.figsize'] = (8, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "11489e4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # read file\n",
    "# raw_x_df = pd.read_csv('./data/train_x_df.csv')\n",
    "# raw_y_df = pd.read_csv('./data/train_y_df.csv')\n",
    "\n",
    "# print('Read files Complete!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5bc9353f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ================================================= #\n",
    "def df2d_to_array3d(df_2d):\n",
    "    \n",
    "    # 입력 받은 2차원 데이터 프레임을 3차원 numpy array로 변경하는 함수\n",
    "    feature_size = df_2d.iloc[:,2:].shape[1]\n",
    "    time_size = len(df_2d.time.value_counts())\n",
    "    sample_size = len(df_2d.sample_id.value_counts())\n",
    "    array_3d = df_2d.iloc[:,2:].values.reshape([sample_size, time_size, feature_size])\n",
    "    \n",
    "    print('DataFrame to array, Complete!')\n",
    "    \n",
    "    return array_3d\n",
    "\n",
    "# ================================================= #\n",
    "\n",
    "def simple_exponetial_smoothing_fory(arr, alpha=0.3):\n",
    "    \n",
    "    y_series = list()\n",
    "\n",
    "    for temp_arr in arr:\n",
    "        target_series = temp_arr[:].reshape(-1) # open col is 1 index\n",
    "\n",
    "        smoother = SimpleExpSmoothing(target_series, initialization_method=\"heuristic\").fit(smoothing_level=alpha,optimized=False)\n",
    "        smoothing_series = smoother.fittedvalues\n",
    "\n",
    "        y_series.append(smoothing_series)\n",
    "            \n",
    "    return np.array(y_series)\n",
    "\n",
    "# ================================================= #\n",
    "\n",
    "def simple_exponetial_smoothing_forX(arr, alpha=0.3):\n",
    "    \n",
    "    # initialization\n",
    "    sample_size = int(arr.shape[0])\n",
    "    time_size = int(arr.shape[1])\n",
    "    feature_size = int(arr.shape[2])\n",
    "    \n",
    "    # create empty array\n",
    "    smoothing_arr = np.zeros((sample_size, time_size, feature_size - 1))\n",
    "\n",
    "    for idx, temp_arr in enumerate(arr):\n",
    "        for col in range(1, feature_size): # open col is 1 index\n",
    "            if col < 5:\n",
    "\n",
    "                temp_series = temp_arr[:, col].reshape(-1) \n",
    "                smoother = SimpleExpSmoothing(temp_series, initialization_method=\"heuristic\").fit(smoothing_level=0.3,optimized=False)\n",
    "                temp_smoothing_series = smoother.fittedvalues\n",
    "                smoothing_arr[idx, :, col-1] = temp_smoothing_series\n",
    "\n",
    "            else:\n",
    "                \n",
    "                pass_series = temp_arr[:, col].reshape(-1)\n",
    "                smoothing_arr[idx, :, col-1] = pass_series\n",
    "\n",
    "    return smoothing_arr\n",
    "\n",
    "\n",
    "# ================================================= #\n",
    "def kbindiscreter(input_array):\n",
    "    kb = KBinsDiscretizer(n_bins=100, strategy='uniform', encode='ordinal')\n",
    "    processed_data = np.zeros((input_array.shape[0], input_array.shape[1], 1))\n",
    "    \n",
    "    for i in range(input_array.shape[0]):\n",
    "        # coin_index_export args : (input_array, coin_num)\n",
    "        processing_array = input_array[i,:,1]\n",
    "        #globals()['outliery_array{}'.format(i)] = train_y_array[outlier[i],:,1]\n",
    "        kb.fit(processing_array.reshape(input_array.shape[1],1))\n",
    "        processed_fit = kb.transform(processing_array.reshape(input_array.shape[1],1))\n",
    "        #globals()['outliery_fit{}'.format(i)] = kb.transform(globals()['outliery_array{}'.format(i)].reshape(120,1))\n",
    "        processed_data[i,:,:] = processed_fit\n",
    "        \n",
    "    return processed_data\n",
    "\n",
    "def moving_average(arr, window_size = 60):\n",
    "    \n",
    "    #length = ma 몇 할지\n",
    "    length = window_size\n",
    "    ma = np.zeros((arr.shape[0], arr.shape[1] - length, arr.shape[2]))\n",
    "\n",
    "    for idx in range(arr.shape[0]):\n",
    "        for i in range(length, arr.shape[1]):\n",
    "            for col in range(arr.shape[2]):\n",
    "                ma[idx, i-length, col] = arr[idx,i-length:i, col].mean() #open\n",
    "            \n",
    "    return ma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "d325cf05",
   "metadata": {},
   "outputs": [],
   "source": [
    "merged_df = pd.read_hdf('./data/merged_allcoin.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "f90853e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataFrame to array, Complete!\n"
     ]
    }
   ],
   "source": [
    "merged_arr = df2d_to_array3d(merged_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "e02ffaa9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7661, 1500, 10)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merged_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "7c4c8de8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# with open('./data/ma60_merged_data.npy', 'rb') as f:\n",
    "#     ma60_merged_arr = np.load(f) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b860a5b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def time_split(input_array, split_size = 6):\n",
    "\n",
    "    # origin size define\n",
    "    index_size = input_array.shape[0]\n",
    "    origin_time_size = input_array.shape[1]\n",
    "    variable_size = input_array.shape[2]\n",
    "\n",
    "    # new array size define\n",
    "    new_time_size = int(origin_time_size/split_size) # 1380 / 6\n",
    "    new_array = np.zeros((index_size, new_time_size, variable_size))\n",
    "\n",
    "    for idx in range(index_size):\n",
    "        for time_idx in range(new_time_size):\n",
    "            \n",
    "\n",
    "            first_time_idx = time_idx * split_size\n",
    "            last_time_idx = ((time_idx+1) * split_size) -1\n",
    "\n",
    "            new_array[idx, time_idx, 0] = input_array[idx, first_time_idx, 0] #coin_num\n",
    "    return new_array\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "id": "dbfa04d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# bins_merged_arr = kbindiscreter(merged_arr)\n",
    "# split_merged_arr = time_split(bins_merged_arr)\n",
    "# mooth_merged_arr = simple_exponetial_smoothing_fory(split_merged_arr)\n",
    "\n",
    "# bins_x_arr = kbindiscreter(raw_x_arr)\n",
    "# bins_y_arr = kbindiscreter(raw_y_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "id": "8244633f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# bins_x_arr = time_split(bins_x_arr)\n",
    "# bins_x_arr = simple_exponetial_smoothing_fory(bins_x_arr)\n",
    "\n",
    "# bins_y_arr = time_split(bins_y_arr)\n",
    "# bins_y_arr = simple_exponetial_smoothing_fory(bins_y_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "64962ca4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7661, 1500, 10)"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "merged_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "fdec5763",
   "metadata": {},
   "outputs": [],
   "source": [
    "# open_y_arr = np.zeros((7661, 5, 1))\n",
    "\n",
    "# for i in range(7661):\n",
    "#     for j in range(5):\n",
    "#         open_y_arr[i, j, :] = raw_y_arr[i, 29 * j, 1]\n",
    "\n",
    "        \n",
    "# y_train = np.zeros((7661))\n",
    "# for i in range(7661):\n",
    "#     y_train[i, ] = np.argmax(open_y_arr[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "bc10d464",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# train & val set\n",
    "train_set, val_set = train_test_split(merged_arr, test_size = 0.2, shuffle=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "7817d7e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6128, 1533)"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_set), len(val_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "5e8511bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # train & val set\n",
    "# train_X, val_X, train_y, val_y = train_test_split(raw_x_arr[:, :, 1:], y_train, test_size = 0.1, shuffle=False)\n",
    "\n",
    "# print(\n",
    "# f'''\n",
    "# ======================================================\n",
    "# Origin length is {len(raw_x_arr)}, then total split length is {len(raw_x_arr)} + {len(val_X)} = {len(train_X)+len(val_X)}\n",
    "# ======================================================\n",
    "# train X length is {train_X.shape}, train y length is {train_y.shape},\n",
    "# val X length is {val_X.shape}, val y length is {val_y.shape},\n",
    "# '''\n",
    "# # test X length is {test_X.shape}, test y length is {test_y.shape}\n",
    "# )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "c3db513c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "device is cpu\n"
     ]
    }
   ],
   "source": [
    "# ====== initialization\n",
    "parser = argparse.ArgumentParser()\n",
    "args = parser.parse_args(\"\")\n",
    "args.device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(\"device is\",args.device)\n",
    "\n",
    "seed = 777\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "\n",
    "# ====== Model Capacity options ===== #\n",
    "args.input_dim = 9\n",
    "args.hidden_dim = 64\n",
    "args.output_dim = 1\n",
    "args.n_layers = 1\n",
    "args.batch_size = 16\n",
    "args.x_frames = 1380\n",
    "args.y_frames = 120\n",
    "\n",
    "# ====== Model training options ===== #\n",
    "args.num_epoch = 20\n",
    "args.learning_rate = 0.0001\n",
    "args.L2_rate = 0.00001\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "id": "52b7d8e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class WindowGenerator(TensorDataset):\n",
    "    \n",
    "    ''' Dataset Generate'''\n",
    "    def __init__(self, data_set, x_frames, y_frames):\n",
    "    \n",
    "        self.data_set = data_set\n",
    "        self.x_frames = x_frames\n",
    "        self.y_frames = y_frames\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data_set)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        \n",
    "        X = self.data_set[idx, :-self.y_frames, 1:]\n",
    "        y = self.data_set[idx, -self.y_frames:, 1]\n",
    "        \n",
    "        X = np.log(X + 1) - np.log(X[-1, :] + 1)\n",
    "    \n",
    "        \n",
    "        return X, y\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "id": "7cd766c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "trainset = WindowGenerator(train_set, 1380, 120) # elf, data_set, x_frames, y_frames):\n",
    "trainloader = DataLoader(trainset, batch_size = args.batch_size,shuffle = True, drop_last = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "id": "56cabbbe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([16, 9, 1380])\n",
      "torch.Size([16, 120])\n"
     ]
    }
   ],
   "source": [
    "for i, (X,y) in enumerate(trainloader):\n",
    "    print(X.transpose(1, 2).shape)\n",
    "    print(y.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "id": "a48f4546",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN_LSTM(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_dim, hidden_dim, output_dim):\n",
    "        super(CNN_LSTM, self).__init__()\n",
    "        \n",
    "        self.input_dim = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.output_dim = output_dim\n",
    "\n",
    "        self.conv1 = nn.Conv1d(arg.input_dim, args.hidden_dim, kernel_size = 10)\n",
    "        self.pooling1 = nn.MaxPool1d(2, stride = 5)\n",
    "        self.conv2 = nn.Conv1d(args.hidden_dim, args.hidden_dim // 2, kernel_size = 5)\n",
    "        self.pooling2 = nn.MaxPool1d(2, stride = 2)\n",
    "        \n",
    "        self.norm = nn.BatchNorm1d(args.hidden_dim // 2)\n",
    "        \n",
    "        self.lstm = nn.LSTM(args.hidden_dim // 2, (args.hidden_dim // 2)/2 , 1, batch_first = True, bidirectional = True)\n",
    "        self.linear = nn.Linear(args.hidden_dim // 2, args.output_dim)\n",
    "        \n",
    "        \n",
    "    def init_hidden(self, batch_size):\n",
    "        return (torch.zeros(self.num_layers, batch_size, self.hidden_dim),\n",
    "                torch.zeros(self.num_layers, batch_size, self.hidden_dim))\n",
    "    \n",
    "    \n",
    "    def forward(self, X):\n",
    "        \n",
    "        # input은 (Batch, Feature dimension, Time_step)순\n",
    "        output = F.relu(conv1(X))\n",
    "        output = pooling1(output)\n",
    "        output = F.relu(conv2(output))\n",
    "        output = pooling2(output)\n",
    "        output = norm1(output)\n",
    "        \n",
    "        # [Batch_size, Seq_len, Hidden_size]\n",
    "        print(output.shape)\n",
    "        output = output.transpose(1, 2)\n",
    "        print(output.shape)\n",
    "        \n",
    "        output, self.hidden = self.lstm(output)\n",
    "        y_pred = self.linear(output[:, -1, :])\n",
    "        \n",
    "        return y_pred\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "7a96bc60",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSTM(nn.Module):\n",
    "    \n",
    "    def __init__(self, input_dim, hidden_dim, output_dim, num_layers, dropout, use_bn):\n",
    "        super(LSTM, self).__init__()\n",
    "        self.input_dim = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.output_dim = output_dim\n",
    "        self.num_layers = num_layers\n",
    "\n",
    "        self.dropout = dropout\n",
    "        self.use_bn = use_bn \n",
    "        self.lstm = nn.LSTM(self.input_dim, self.hidden_dim, self.num_layers, batch_first =True)\n",
    "\n",
    "        self.fc = self.make_regressor()\n",
    "        \n",
    "    def init_hidden(self, batch_size):\n",
    "        return (torch.zeros(self.num_layers, batch_size, self.hidden_dim),\n",
    "                torch.zeros(self.num_layers, batch_size, self.hidden_dim))\n",
    "    \n",
    "    def make_regressor(self):\n",
    "        layers = []\n",
    "        if self.use_bn:\n",
    "            layers.append(nn.BatchNorm1d(self.hidden_dim))\n",
    "        layers.append(nn.Dropout(self.dropout))\n",
    "        \n",
    "        layers.append(nn.Linear(self.hidden_dim, 200))\n",
    "        layers.append(nn.ReLU())\n",
    "        layers.append(nn.Linear(200, self.output_dim))\n",
    "        regressor = nn.Sequential(*layers)\n",
    "        return regressor\n",
    "    \n",
    "    def forward(self, X):\n",
    "        lstm_out, self.hidden = self.lstm(X)\n",
    "        y_pred = self.fc(lstm_out[:, -1, :])\n",
    "        return y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "8df48329",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, partition, optimizer, loss_fn, args):\n",
    "    ''' model training '''\n",
    "   \n",
    "    # data load\n",
    "    trainloader = DataLoader(partition['train'],\n",
    "                             batch_size = args.batch_size,\n",
    "                             shuffle = True, drop_last = True)\n",
    "    \n",
    "    # model's mode setting\n",
    "    model.train()\n",
    "    model.zero_grad()\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "    train_loss = 0.0\n",
    "    for i, (X, y) in enumerate(trainloader):\n",
    "    \n",
    "        X = X.float().to(args.device)\n",
    "        y_true = y.long().to(args.device)\n",
    "        \n",
    "#         print(X.shape, y_true.shape)\n",
    "        \n",
    "        # zero the gradient\n",
    "        model.zero_grad()\n",
    "        optimizer.zero_grad()\n",
    "        model.hidden = model.init_hidden(X.shape[1])\n",
    "\n",
    "        y_pred = model(X)\n",
    "#         print(y_pred.shape)\n",
    "\n",
    "        loss = loss_fn(y_pred, y_true)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        train_loss += loss.item()\n",
    "\n",
    "    train_loss = train_loss / len(trainloader)\n",
    "    return model, train_loss\n",
    "\n",
    "\n",
    "def validate(model, partition, loss_fn, args):\n",
    "    ''' model validate '''\n",
    "    \n",
    "    # data load\n",
    "    valloader = DataLoader(partition['val'], \n",
    "                           batch_size = args.batch_size, \n",
    "                           shuffle = False, drop_last = True)\n",
    "    \n",
    "    # model's mode setting\n",
    "    model.eval()\n",
    "    val_loss = 0.0\n",
    "    correct, total = 0, 0\n",
    "    # evaluate\n",
    "    with torch.no_grad():\n",
    "        for i, (X, y) in enumerate(valloader):\n",
    "            \n",
    "            X = X.float().to(args.device)\n",
    "            y_true = y.long().to(args.device)\n",
    "            \n",
    "            model.hidden = model.init_hidden(X.shape[1])\n",
    "            # en-decoder outputs tensor \n",
    "            y_pred = model(X)\n",
    "            \n",
    "            # compute the loss\n",
    "            loss = loss_fn(y_pred, y_true)\n",
    "            val_loss += loss.item()\n",
    "            \n",
    "            preds = F.log_softmax(y_pred, dim=1).argmax(dim=1)\n",
    "            total += y_true.size(0)\n",
    "            correct += (preds == y_val).sum().item()\n",
    "            \n",
    "    val_loss = val_loss / len(valloader)\n",
    "    val_acc = correct / total\n",
    "    return val_loss, val_acc\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "851b2276",
   "metadata": {},
   "outputs": [],
   "source": [
    "def experiment(partition, args):\n",
    "\n",
    "    model = LSTM(args.input_dim, args.hidden_dim, args.output_dim, args.n_layers, args.dropout, args.use_bn)\n",
    "    model.to(args.device)\n",
    "    \n",
    "    loss_fn = nn.CrossEntropyLoss()\n",
    "    optimizer = optim.RMSprop(model.parameters(), lr=args.learning_rate, weight_decay=args.L2_rate)\n",
    "    \n",
    "    # epoch-wise loss\n",
    "    train_losses = []\n",
    "    val_losses = []\n",
    "    val_accs = []\n",
    "    \n",
    "    for epoch in range(args.num_epoch):\n",
    "        \n",
    "        start_time = time.time()\n",
    "        model, train_loss = train(model, partition, optimizer, loss_fn, args)\n",
    "        val_loss, val_acc = validate(model, partition, loss_fn, args)\n",
    "        end_time = time.time()\n",
    "        \n",
    "        # add epoch loss\n",
    "        train_losses.append(train_loss)\n",
    "        val_losses.append(val_loss)\n",
    "        train_accs.append(train_acc)\n",
    "        val_accs.append(val_acc)\n",
    "        \n",
    "        print('Epoch {}, Acc(train/val): {:2.2f}/{:2.2f}, Loss(train/val) {:2.5f}/{:2.5f}. Took {:2.2f} sec'.format(\n",
    "            epoch+1, val_acc, train_loss, val_loss, end_time-start_time))\n",
    "    \n",
    "\n",
    "    # ======= Add Result to Dictionary ======= #\n",
    "    result = {}\n",
    "    \n",
    "    result['train_losses'] = train_losses\n",
    "    result['val_losses'] = val_losses\n",
    "        \n",
    "    return vars(args), result, model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "560baaf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# train_X, val_X, train_y, val_y = train_test_split(raw_x_arr[:, :, 1:], y_train, test_size = 0.1, shuffle=False)\n",
    "trainset = WindowGenerator(train_X, train_y, args.x_frames)\n",
    "valset = WindowGenerator(val_X, val_y, args.x_frames)\n",
    "\n",
    "partition = {'train': trainset, 'val':valset}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "d95bbe3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Namespace(L2_rate=0.0001, batch_size=16, device='cpu', dropout=0.2, hidden_dim=100, input_dim=9, learning_rate=0.0001, n_layers=1, num_epoch=20, output_dim=9, use_bn=True, x_frames=1380)\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-65-1629c9e68dc6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0msetting\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mexperiment\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpartition\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdeepcopy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-63-cddbfb03c8a0>\u001b[0m in \u001b[0;36mexperiment\u001b[1;34m(partition, args)\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m         \u001b[0mstart_time\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m         \u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrain_loss\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpartition\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mloss_fn\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     18\u001b[0m         \u001b[0mval_loss\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mval_acc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mvalidate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpartition\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mloss_fn\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     19\u001b[0m         \u001b[0mend_time\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-62-18f2a1429041>\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(model, partition, optimizer, loss_fn, args)\u001b[0m\n\u001b[0;32m     29\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     30\u001b[0m         \u001b[0mloss\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mloss_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my_pred\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_true\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 31\u001b[1;33m         \u001b[0mloss\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     32\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     33\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Anaconda3\\envs\\venv\\lib\\site-packages\\torch\\tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[0;32m    183\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[1;33m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    184\u001b[0m         \"\"\"\n\u001b[1;32m--> 185\u001b[1;33m         \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    186\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    187\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mC:\\Anaconda3\\envs\\venv\\lib\\site-packages\\torch\\autograd\\__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[0;32m    125\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[0;32m    126\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 127\u001b[1;33m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[0;32m    128\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    129\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "print(args)\n",
    "setting, result, model = experiment(partition, deepcopy(args))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "563c8828",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "testloader = DataLoader(partition['train'], batch_size = 1, shuffle = True, drop_last = True)\n",
    "model.eval()\n",
    "# evaluate\n",
    "\n",
    "with torch.no_grad():\n",
    "    for i, (X, y) in enumerate(testloader):\n",
    "\n",
    "        X = X.transpose(0, 1).float().to(args.device)\n",
    "        y_true = y.float().to(args.device)\n",
    "        model.hidden = model.init_hidden(X.shape[1])\n",
    "\n",
    "        # en-decoder outputs tensor \n",
    "        y_pred = model(X)\n",
    "        \n",
    "        # y values to cpu\n",
    "        y_true = y_true.cpu().detach().numpy().reshape(-1)\n",
    "        y_pred = y_pred.cpu().detach().numpy().reshape(-1)\n",
    "        \n",
    "        print(y_true.shape, y_pred.shape)\n",
    "\n",
    "        plt.plot(y_true, label = 'True series')\n",
    "        plt.plot(y_pred, '-', label = 'Prediction series')\n",
    "#         plt.plot(.max(), '*')\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "\n",
    "        loss = mean_absolute_error(y_true, y_pred)\n",
    "        mae =+ loss\n",
    "        if i == 10:\n",
    "            print(args, \"\\nSES 사용\")\n",
    "            print(f'mean absolute error * 10E5 is {(mae/5) * 10E5}')            \n",
    "            break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5168aae0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8345f11",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "955bb48b",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}