convnet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "CUDA error: device-side assert triggered\nCUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1.\nCompile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.\n",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[33], line 24\u001b[0m\n\u001b[0;32m     22\u001b[0m random\u001b[39m.\u001b[39mseed(SEED)\n\u001b[0;32m     23\u001b[0m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39mseed(SEED)\n\u001b[1;32m---> 24\u001b[0m torch\u001b[39m.\u001b[39;49mmanual_seed(SEED)\n\u001b[0;32m     25\u001b[0m torch\u001b[39m.\u001b[39mcuda\u001b[39m.\u001b[39mmanual_seed(SEED)\n\u001b[0;32m     26\u001b[0m torch\u001b[39m.\u001b[39mbackends\u001b[39m.\u001b[39mcudnn\u001b[39m.\u001b[39mdeterministic \u001b[39m=\u001b[39m \u001b[39mTrue\u001b[39;00m\n",
      "File \u001b[1;32mc:\\Users\\Tony\\anaconda3\\lib\\site-packages\\torch\\random.py:40\u001b[0m, in \u001b[0;36mmanual_seed\u001b[1;34m(seed)\u001b[0m\n\u001b[0;32m     37\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtorch\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcuda\u001b[39;00m\n\u001b[0;32m     39\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m torch\u001b[39m.\u001b[39mcuda\u001b[39m.\u001b[39m_is_in_bad_fork():\n\u001b[1;32m---> 40\u001b[0m     torch\u001b[39m.\u001b[39;49mcuda\u001b[39m.\u001b[39;49mmanual_seed_all(seed)\n\u001b[0;32m     42\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtorch\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmps\u001b[39;00m\n\u001b[0;32m     43\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m torch\u001b[39m.\u001b[39mmps\u001b[39m.\u001b[39m_is_in_bad_fork():\n",
      "File \u001b[1;32mc:\\Users\\Tony\\anaconda3\\lib\\site-packages\\torch\\cuda\\random.py:113\u001b[0m, in \u001b[0;36mmanual_seed_all\u001b[1;34m(seed)\u001b[0m\n\u001b[0;32m    110\u001b[0m         default_generator \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mcuda\u001b[39m.\u001b[39mdefault_generators[i]\n\u001b[0;32m    111\u001b[0m         default_generator\u001b[39m.\u001b[39mmanual_seed(seed)\n\u001b[1;32m--> 113\u001b[0m _lazy_call(cb, seed_all\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n",
      "File \u001b[1;32mc:\\Users\\Tony\\anaconda3\\lib\\site-packages\\torch\\cuda\\__init__.py:183\u001b[0m, in \u001b[0;36m_lazy_call\u001b[1;34m(callable, **kwargs)\u001b[0m\n\u001b[0;32m    181\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_lazy_call\u001b[39m(callable, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m    182\u001b[0m     \u001b[39mif\u001b[39;00m is_initialized():\n\u001b[1;32m--> 183\u001b[0m         callable()\n\u001b[0;32m    184\u001b[0m     \u001b[39melse\u001b[39;00m:\n\u001b[0;32m    185\u001b[0m         \u001b[39m# TODO(torch_deploy): this accesses linecache, which attempts to read the\u001b[39;00m\n\u001b[0;32m    186\u001b[0m         \u001b[39m# file system to get traceback info. Patch linecache or do something\u001b[39;00m\n\u001b[0;32m    187\u001b[0m         \u001b[39m# else here if this ends up being important.\u001b[39;00m\n\u001b[0;32m    188\u001b[0m         \u001b[39mglobal\u001b[39;00m _lazy_seed_tracker\n",
      "File \u001b[1;32mc:\\Users\\Tony\\anaconda3\\lib\\site-packages\\torch\\cuda\\random.py:111\u001b[0m, in \u001b[0;36mmanual_seed_all.<locals>.cb\u001b[1;34m()\u001b[0m\n\u001b[0;32m    109\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(device_count()):\n\u001b[0;32m    110\u001b[0m     default_generator \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mcuda\u001b[39m.\u001b[39mdefault_generators[i]\n\u001b[1;32m--> 111\u001b[0m     default_generator\u001b[39m.\u001b[39;49mmanual_seed(seed)\n",
      "\u001b[1;31mRuntimeError\u001b[0m: CUDA error: device-side assert triggered\nCUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1.\nCompile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch.utils.data import TensorDataset, DataLoader, RandomSampler\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "import math\n",
    "import time\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "device=\"cpu\"\n",
    "print(device)\n",
    "\n",
    "SEED = 1234\n",
    "\n",
    "random.seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "torch.manual_seed(SEED)\n",
    "torch.cuda.manual_seed(SEED)\n",
    "torch.backends.cudnn.deterministic = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#################LOAD DATA############################\n",
    "path = \"C:/Users/Tony/Documents/TestData/data/\"\n",
    "dataset = pd.read_csv(path+\"low_dataset.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "SOS_token = 0\n",
    "EOS_token = 0\n",
    "\n",
    "class Mydataset(Dataset):\n",
    "    def __init__(self, inputs, targets):\n",
    "        self.targets = targets\n",
    "        self.inputs = inputs\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.inputs)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.inputs[idx], self.targets[idx]\n",
    "\n",
    "def get_au_dictionary(dataframe):\n",
    "    dic = {}\n",
    "    groups = dataframe.groupby('script_id').groups #group by duplicates script_id and return a dictionary of indexes where the key is the script_id and the value is a list of indexes\n",
    "    for key, val in groups.items():\n",
    "        dt_indexed = dataframe.iloc[val]  #iloc is for integer indexing\n",
    "        au = dt_indexed.loc[:, dt_indexed.columns.str.endswith(\"_r\")] #loc is for label indexing\n",
    "        dic[key] = au\n",
    "    return dic\n",
    "\n",
    "def prepare_data(data, only_bs=True):\n",
    "    ##pairs are same script name over n number of lines\n",
    "    ##while name is not different, take the first 17 au columns, and the last 61 columns (ARKIT results) to form a pair\n",
    "    ##return a list of pairs of dataframe\n",
    "    pairs = []\n",
    "    groups = data.groupby('script_id').groups #group by duplicates script_id and return a dictionary of indexes where the key is the script_id and the value is a list of indexes\n",
    "    for key, val in groups.items():\n",
    "        dt_indexed = data.iloc[val]  #iloc is for integer indexing\n",
    "        au = dt_indexed.loc[:, dt_indexed.columns.str.endswith(\"_r\")] #loc is for label indexing\n",
    "        bs = dt_indexed.iloc[:, -61:] #selects the last 61 columns corresponding to blendshapes + eyes rotation and head rotation in 3 axes (+ 9 variables) )\n",
    "        if only_bs:\n",
    "            bs = bs.iloc[:, :-9] #Drop the 9 columns not related to blendshapes (eyes + head rotation)\n",
    "        length = au.shape[0]\n",
    "        pairs.append((au, bs, length))\n",
    "    return pairs\n",
    "\n",
    "def sort_pairs(pairs):\n",
    "    return [(inp, tgt, l) for inp, tgt, l in pairs if l < MAX_LENGTH ]\n",
    "    \n",
    "\n",
    "def my_collate_fn(batch):\n",
    "    #sort batch in descending order\n",
    "    #Batch is list of tuples\n",
    "    inp = [x[0] for x in batch]\n",
    "    tgt = [x[1] for x in batch]\n",
    "    sorted_inp = sorted(inp, key=lambda x: x.shape[0], reverse=True)\n",
    "    sorted_tgt = sorted(tgt, key=lambda x: x.shape[0], reverse=True)\n",
    "    #get a list of each batch length\n",
    "    lengths_of_batches = torch.LongTensor([x.shape[0] for x in sorted_inp])\n",
    "    input_tensors = [torch.FloatTensor(inp).to(device) for inp in sorted_inp]\n",
    "    target_tensors = [torch.FloatTensor(tgt).to(device) for tgt in sorted_tgt]\n",
    "    padded_input = torch.nn.utils.rnn.pad_sequence(input_tensors)\n",
    "    padded_target = torch.nn.utils.rnn.pad_sequence(target_tensors)\n",
    "    return padded_input, padded_target, lengths_of_batches\n",
    "\n",
    "#padded sequence\n",
    "def get_dataloader(batch_size, data, train_data_percentage=0.7, test_data_percentage=0.2,short_sentences=False, only_bs=True):\n",
    "    if train_data_percentage + test_data_percentage >= 1:\n",
    "        print(\"train + test data_percentage must be lower than 1. You need room for the valid dataset\")\n",
    "        return\n",
    "    pairs = prepare_data(data, only_bs=only_bs)\n",
    "    if short_sentences:\n",
    "        pairs = sort_pairs(pairs)\n",
    "    inputs = [x[0].to_numpy() for x in pairs]\n",
    "    targets = [x[1].to_numpy() for x in pairs]\n",
    "    data = Mydataset(inputs, targets)\n",
    "    generator = torch.Generator().manual_seed(42) #for reproductability\n",
    "    train_size = int(train_data_percentage * len(data))\n",
    "    test_size = int(test_data_percentage*len(data))\n",
    "    val_size = int(len(data) - train_size - test_size)\n",
    "    train_dataset, validation_dataset, test_dataset = torch.utils.data.random_split(data, [train_size, val_size, test_size], generator=generator)\n",
    "    \n",
    "    train_sampler = RandomSampler(train_dataset)\n",
    "    test_sampler = RandomSampler(test_dataset)\n",
    "    valid_sampler = RandomSampler(validation_dataset)\n",
    "\n",
    "    train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=batch_size, collate_fn=my_collate_fn)\n",
    "    test_dataloader = DataLoader(test_dataset, sampler=test_sampler, batch_size=batch_size, collate_fn=my_collate_fn)\n",
    "    validation_dataloader = DataLoader(validation_dataset, sampler=valid_sampler, batch_size=batch_size, collate_fn=my_collate_fn)\n",
    "    return [train_dataloader, validation_dataloader, test_dataloader]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ConvNet FROM : https://github.com/bentrevett/pytorch-seq2seq/blob/master/5%20-%20Convolutional%20Sequence%20to%20Sequence%20Learning.ipynb\n",
    "\n",
    "class Encoder(nn.Module):\n",
    "    def __init__(self, \n",
    "                 input_dim,\n",
    "                 emb_dim,\n",
    "                 hid_dim, \n",
    "                 n_layers, \n",
    "                 kernel_size, \n",
    "                 dropout, \n",
    "                 device,\n",
    "                 max_length = 100):\n",
    "        super().__init__()\n",
    "        \n",
    "        assert kernel_size % 2 == 1, \"Kernel size must be odd!\"\n",
    "        \n",
    "        self.device = device\n",
    "        \n",
    "        self.scale = torch.sqrt(torch.FloatTensor([0.5])).to(device)\n",
    "        self.emb = nn.Linear(input_dim, emb_dim)\n",
    "        self.emb2hid = nn.Linear(emb_dim, hid_dim)\n",
    "        self.hid2emb = nn.Linear(hid_dim, emb_dim)\n",
    "        self.pos_embedding = nn.Embedding(max_length, emb_dim)\n",
    "        self.convs = nn.ModuleList([nn.Conv1d(in_channels = hid_dim, \n",
    "                                              out_channels = 2 * hid_dim, \n",
    "                                              kernel_size = kernel_size, \n",
    "                                              padding = (kernel_size - 1) // 2)\n",
    "                                    for _ in range(n_layers)])\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, src):\n",
    "        \n",
    "        #src = [batch size, src len, input_size]\n",
    "        \n",
    "        batch_size = src.shape[0]\n",
    "        src_len = src.shape[1]\n",
    "        \n",
    "        pos = torch.arange(0, src_len).unsqueeze(0).repeat(batch_size, 1).to(self.device)\n",
    "        pos_embedded = self.pos_embedding(pos)\n",
    "        \n",
    "        #combine embeddings by elementwise summing\n",
    "        embedded = (self.emb(src) + pos_embedded)\n",
    "        conv_input = self.emb2hid(self.dropout(embedded))\n",
    "        #conv_input = [batch size, src len, hid dim]\n",
    "        \n",
    "        #permute for convolutional layer\n",
    "        conv_input = conv_input.permute(0, 2, 1) \n",
    "        \n",
    "        #conv_input = [batch size, hid dim, src len]\n",
    "        \n",
    "        #begin convolutional blocks...\n",
    "        \n",
    "        for i, conv in enumerate(self.convs):\n",
    "        \n",
    "            #pass through convolutional layer\n",
    "            conved = conv(self.dropout(conv_input))\n",
    "\n",
    "            #conved = [batch size, 2 * hid dim, src len]\n",
    "\n",
    "            #pass through GLU activation function\n",
    "            conved = F.glu(conved, dim = 1)\n",
    "\n",
    "            #conved = [batch size, hid dim, src len]\n",
    "            \n",
    "            #apply residual connection\n",
    "            conved = (conved + conv_input) * self.scale\n",
    "\n",
    "            #conved = [batch size, hid dim, src len]\n",
    "            \n",
    "            #set conv_input to conved for next loop iteration\n",
    "            conv_input = conved\n",
    "        \n",
    "        #...end convolutional blocks\n",
    "        \n",
    "        #permute and convert back to emb dim\n",
    "        conved = self.hid2emb(conved.permute(0, 2, 1))\n",
    "        #conved = [batch size, src len, hid dim]\n",
    "        \n",
    "        #elementwise sum output (conved) and input (embedded) to be used for attention\n",
    "        combined = (conved + embedded) * self.scale\n",
    "        \n",
    "        #combined = [batch size, src len, hid dim]\n",
    "        \n",
    "        return conved, combined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    def __init__(self, \n",
    "                 output_dim,\n",
    "                 emb_dim,\n",
    "                 hid_dim, \n",
    "                 n_layers, \n",
    "                 kernel_size, \n",
    "                 dropout, \n",
    "                 trg_pad_idx, \n",
    "                 device,\n",
    "                 max_length = 100):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.kernel_size = kernel_size\n",
    "        self.trg_pad_idx = trg_pad_idx\n",
    "        self.device = device\n",
    "    \n",
    "        self.scale = torch.sqrt(torch.FloatTensor([0.5])).to(device)\n",
    "        self.emb = nn.Linear(output_dim, emb_dim)\n",
    "\n",
    "        self.pos_embedding = nn.Embedding(max_length, emb_dim)\n",
    "        self.emb2hid = nn.Linear(emb_dim, hid_dim)\n",
    "        self.hid2emb = nn.Linear(hid_dim, emb_dim)\n",
    "        \n",
    "        self.attn_hid2emb = nn.Linear(hid_dim, emb_dim)\n",
    "        self.attn_emb2hid = nn.Linear(emb_dim, hid_dim)\n",
    "\n",
    "\n",
    "        self.fc_out = nn.Linear(hid_dim, output_dim)\n",
    "        \n",
    "        self.convs = nn.ModuleList([nn.Conv1d(in_channels = hid_dim, \n",
    "                                              out_channels = 2 * hid_dim, \n",
    "                                              kernel_size = kernel_size)\n",
    "                                    for _ in range(n_layers)])\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "      \n",
    "    def calculate_attention(self, embedded, conved, encoder_conved, encoder_combined):\n",
    "        conved_emb = self.attn_hid2emb(conved.permute(0, 2, 1))\n",
    "        \n",
    "        #combined = [batch size, trg len, hid dim]\n",
    "        combined = (conved_emb + embedded) * self.scale\n",
    "        #energy = [batch size, trg len, src len]\n",
    "        energy = torch.matmul(combined, encoder_conved.permute(0, 2, 1))\n",
    "\n",
    "        attention = F.softmax(energy, dim=2)\n",
    "        \n",
    "        #attention = [batch size, trg len, src len]\n",
    "        attended_encoding = torch.matmul(attention, encoder_combined)\n",
    "        #attended_encoding = [batch size, trg len, hid dim]\n",
    "        \n",
    "        #apply residual connection\n",
    "        attended_combined = (conved + attended_encoding.permute(0, 2, 1)) * self.scale\n",
    "        #attended_combined = [batch size, hid dim, trg len]\n",
    "        \n",
    "        return attention, attended_combined\n",
    "        \n",
    "    def forward(self, trg, encoder_conved, encoder_combined):\n",
    "        \n",
    "        #trg = [batch size, trg len]\n",
    "        #encoder_conved = encoder_combined = [batch size, src len, emb dim]\n",
    "        \n",
    "        batch_size = trg.shape[0]\n",
    "        trg_len = trg.shape[1]\n",
    "        pos = torch.arange(0, trg_len).unsqueeze(0).repeat(batch_size, 1).to(self.device)\n",
    "        pos_embedded = self.pos_embedding(pos)\n",
    "\n",
    "        embedded = (self.emb(trg)+pos_embedded)\n",
    "        conv_input = self.emb2hid(self.dropout(embedded))\n",
    "        \n",
    "        #conv_input = [batch size, trg len, hid dim]\n",
    "        \n",
    "        #permute for convolutional layer\n",
    "        conv_input = conv_input.permute(0, 2, 1) \n",
    "        \n",
    "        #conv_input = [batch size, hid dim, trg len]\n",
    "        \n",
    "        batch_size = conv_input.shape[0]\n",
    "        hid_dim = conv_input.shape[1]\n",
    "        \n",
    "        for i, conv in enumerate(self.convs):\n",
    "            #apply dropout\n",
    "            conv_input = self.dropout(conv_input)\n",
    "        \n",
    "            #need to pad so decoder can't \"cheat\"\n",
    "            padding = torch.zeros(batch_size, \n",
    "                                  hid_dim, \n",
    "                                  self.kernel_size - 1).fill_(self.trg_pad_idx).to(self.device)\n",
    "                \n",
    "            padded_conv_input = torch.cat((padding, conv_input), dim = 2)\n",
    "        \n",
    "            #padded_conv_input = [batch size, hid dim, trg len + kernel size - 1]\n",
    "        \n",
    "            #pass through convolutional layer\n",
    "            conved = conv(padded_conv_input)\n",
    "\n",
    "            #conved = [batch size, 2 * hid dim, trg len]\n",
    "            \n",
    "            #pass through GLU activation function\n",
    "            conved = F.glu(conved, dim = 1)\n",
    "\n",
    "            #conved = [batch size, hid dim, trg len]\n",
    "            \n",
    "            #calculate attention\n",
    "            attention, conved = self.calculate_attention(embedded, \n",
    "                                                         conved, \n",
    "                                                         encoder_conved, \n",
    "                                                         encoder_combined)\n",
    "            \n",
    "            #attention = [batch size, trg len, src len]\n",
    "            \n",
    "            #apply residual connection\n",
    "            conved = (conved + conv_input) * self.scale\n",
    "            \n",
    "            #conved = [batch size, hid dim, trg len]\n",
    "            \n",
    "            #set conv_input to conved for next loop iteration\n",
    "            conv_input = conved\n",
    "        output = self.fc_out(self.dropout(conved))\n",
    "        \n",
    "        #output = [batch size, trg len, output dim]\n",
    "            \n",
    "        return output, attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2Seq(nn.Module):\n",
    "    def __init__(self, encoder, decoder):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.encoder = encoder\n",
    "        self.decoder = decoder\n",
    "        \n",
    "    def forward(self, src, trg):\n",
    "        \n",
    "        #src = [batch size, src len]\n",
    "        #trg = [batch size, trg len - 1] (<eos> token sliced off the end)\n",
    "           \n",
    "        #calculate z^u (encoder_conved) and (z^u + e) (encoder_combined)\n",
    "        #encoder_conved is output from final encoder conv. block\n",
    "        #encoder_combined is encoder_conved plus (elementwise) src embedding plus \n",
    "        #  positional embeddings \n",
    "        encoder_conved, encoder_combined = self.encoder(src)\n",
    "            \n",
    "        #encoder_conved = [batch size, src len, emb dim]\n",
    "        #encoder_combined = [batch size, src len, emb dim]\n",
    "        \n",
    "        #calculate predictions of next words\n",
    "        #output is a batch of predictions for each word in the trg sentence\n",
    "        #attention a batch of attention scores across the src sentence for \n",
    "        #  each word in the trg sentence\n",
    "        output, attention = self.decoder(trg, encoder_conved, encoder_combined)\n",
    "        \n",
    "        #output = [batch size, trg len - 1, output dim]\n",
    "        #attention = [batch size, trg len - 1, src len]\n",
    "        \n",
    "        return output, attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "INPUT_DIM = 17\n",
    "OUTPUT_DIM = 52\n",
    "EMB_DIM = 256\n",
    "HID_DIM = 512 # each conv. layer has 2 * hid_dim filters\n",
    "ENC_LAYERS = 10 # number of conv. blocks in encoder\n",
    "DEC_LAYERS = 10 # number of conv. blocks in decoder\n",
    "ENC_KERNEL_SIZE = 3 # must be odd!\n",
    "DEC_KERNEL_SIZE = 3 # can be even or odd\n",
    "ENC_DROPOUT = 0.25\n",
    "DEC_DROPOUT = 0.25\n",
    "TRG_PAD_IDX = 0\n",
    "    \n",
    "enc = Encoder(INPUT_DIM, EMB_DIM, HID_DIM, ENC_LAYERS, ENC_KERNEL_SIZE, ENC_DROPOUT, device)\n",
    "dec = Decoder(OUTPUT_DIM, EMB_DIM, HID_DIM, DEC_LAYERS, DEC_KERNEL_SIZE, DEC_DROPOUT, TRG_PAD_IDX, device)\n",
    "\n",
    "model = Seq2Seq(enc, dec).to(device)\n",
    "optimizer = optim.Adam(model.parameters())\n",
    "criterion = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def train(model, iterator, optimizer, criterion, clip):\n",
    "    \n",
    "    model.train()\n",
    "    \n",
    "    epoch_loss = 0\n",
    "    \n",
    "    for i, batch in enumerate(iterator):\n",
    "        inpt, tgt, l = batch\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        output, _ = model(inpt.permute(1, 0, 2), tgt.permute(1, 0, 2))\n",
    "        \n",
    "        loss = criterion(output.view(-1), tgt.view(-1))\n",
    "        \n",
    "        loss.backward()\n",
    "        \n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), clip)\n",
    "        \n",
    "        optimizer.step()\n",
    "        \n",
    "        epoch_loss += loss.item()\n",
    "        \n",
    "    return epoch_loss / len(iterator)\n",
    "\n",
    "def evaluate(model, iterator, criterion):\n",
    "    \n",
    "    model.eval()\n",
    "    \n",
    "    epoch_loss = 0\n",
    "    \n",
    "    with torch.no_grad():\n",
    "    \n",
    "        for i, batch in enumerate(iterator):\n",
    "\n",
    "            inp, tgt, l = batch\n",
    "            output, _ = model(inp.permute(1, 0, 2), tgt.permute(1, 0, 2))\n",
    "            loss = criterion(output.view(-1), tgt.view(-1))\n",
    "\n",
    "            epoch_loss += loss.item()\n",
    "        \n",
    "    return epoch_loss / len(iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 4\n",
    "train_dataloader, valid_dataloader, test_dataloader = get_dataloader(batch_size, dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nb of batch 164\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "CUDA error: device-side assert triggered\nCUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1.\nCompile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.\n",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[31], line 7\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mnb of batch\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mlen\u001b[39m(train_dataloader))\n\u001b[0;32m      6\u001b[0m start_time \u001b[39m=\u001b[39m time\u001b[39m.\u001b[39mtime()\n\u001b[1;32m----> 7\u001b[0m train_loss \u001b[39m=\u001b[39m train(model, train_dataloader, optimizer, criterion, \u001b[39m1\u001b[39;49m)\n\u001b[0;32m      8\u001b[0m valid_loss \u001b[39m=\u001b[39m evaluate(model, valid_dataloader, criterion)\n\u001b[0;32m     10\u001b[0m train_loss_list\u001b[39m.\u001b[39mappend(train_loss)\n",
      "Cell \u001b[1;32mIn[24], line 7\u001b[0m, in \u001b[0;36mtrain\u001b[1;34m(model, iterator, optimizer, criterion, clip)\u001b[0m\n\u001b[0;32m      3\u001b[0m model\u001b[39m.\u001b[39mtrain()\n\u001b[0;32m      5\u001b[0m epoch_loss \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m\n\u001b[1;32m----> 7\u001b[0m \u001b[39mfor\u001b[39;00m i, batch \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(iterator):\n\u001b[0;32m      8\u001b[0m     inpt, tgt, l \u001b[39m=\u001b[39m batch\n\u001b[0;32m      9\u001b[0m     optimizer\u001b[39m.\u001b[39mzero_grad()\n",
      "File \u001b[1;32mc:\\Users\\Tony\\anaconda3\\lib\\site-packages\\torch\\utils\\data\\dataloader.py:633\u001b[0m, in \u001b[0;36m_BaseDataLoaderIter.__next__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    630\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_sampler_iter \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m    631\u001b[0m     \u001b[39m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[39;00m\n\u001b[0;32m    632\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_reset()  \u001b[39m# type: ignore[call-arg]\u001b[39;00m\n\u001b[1;32m--> 633\u001b[0m data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_next_data()\n\u001b[0;32m    634\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_yielded \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m    635\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_dataset_kind \u001b[39m==\u001b[39m _DatasetKind\u001b[39m.\u001b[39mIterable \u001b[39mand\u001b[39;00m \\\n\u001b[0;32m    636\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_IterableDataset_len_called \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m \\\n\u001b[0;32m    637\u001b[0m         \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_num_yielded \u001b[39m>\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_IterableDataset_len_called:\n",
      "File \u001b[1;32mc:\\Users\\Tony\\anaconda3\\lib\\site-packages\\torch\\utils\\data\\dataloader.py:677\u001b[0m, in \u001b[0;36m_SingleProcessDataLoaderIter._next_data\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    675\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_next_data\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m    676\u001b[0m     index \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_next_index()  \u001b[39m# may raise StopIteration\u001b[39;00m\n\u001b[1;32m--> 677\u001b[0m     data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_dataset_fetcher\u001b[39m.\u001b[39;49mfetch(index)  \u001b[39m# may raise StopIteration\u001b[39;00m\n\u001b[0;32m    678\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_pin_memory:\n\u001b[0;32m    679\u001b[0m         data \u001b[39m=\u001b[39m _utils\u001b[39m.\u001b[39mpin_memory\u001b[39m.\u001b[39mpin_memory(data, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_pin_memory_device)\n",
      "File \u001b[1;32mc:\\Users\\Tony\\anaconda3\\lib\\site-packages\\torch\\utils\\data\\_utils\\fetch.py:54\u001b[0m, in \u001b[0;36m_MapDatasetFetcher.fetch\u001b[1;34m(self, possibly_batched_index)\u001b[0m\n\u001b[0;32m     52\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m     53\u001b[0m     data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdataset[possibly_batched_index]\n\u001b[1;32m---> 54\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcollate_fn(data)\n",
      "Cell \u001b[1;32mIn[20], line 53\u001b[0m, in \u001b[0;36mmy_collate_fn\u001b[1;34m(batch)\u001b[0m\n\u001b[0;32m     51\u001b[0m \u001b[39m#get a list of each batch length\u001b[39;00m\n\u001b[0;32m     52\u001b[0m lengths_of_batches \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mLongTensor([x\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m] \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m sorted_inp])\n\u001b[1;32m---> 53\u001b[0m input_tensors \u001b[39m=\u001b[39m [torch\u001b[39m.\u001b[39mFloatTensor(inp)\u001b[39m.\u001b[39mto(device) \u001b[39mfor\u001b[39;00m inp \u001b[39min\u001b[39;00m sorted_inp]\n\u001b[0;32m     54\u001b[0m target_tensors \u001b[39m=\u001b[39m [torch\u001b[39m.\u001b[39mFloatTensor(tgt)\u001b[39m.\u001b[39mto(device) \u001b[39mfor\u001b[39;00m tgt \u001b[39min\u001b[39;00m sorted_tgt]\n\u001b[0;32m     55\u001b[0m padded_input \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mnn\u001b[39m.\u001b[39mutils\u001b[39m.\u001b[39mrnn\u001b[39m.\u001b[39mpad_sequence(input_tensors)\n",
      "Cell \u001b[1;32mIn[20], line 53\u001b[0m, in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m     51\u001b[0m \u001b[39m#get a list of each batch length\u001b[39;00m\n\u001b[0;32m     52\u001b[0m lengths_of_batches \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mLongTensor([x\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m] \u001b[39mfor\u001b[39;00m x \u001b[39min\u001b[39;00m sorted_inp])\n\u001b[1;32m---> 53\u001b[0m input_tensors \u001b[39m=\u001b[39m [torch\u001b[39m.\u001b[39;49mFloatTensor(inp)\u001b[39m.\u001b[39;49mto(device) \u001b[39mfor\u001b[39;00m inp \u001b[39min\u001b[39;00m sorted_inp]\n\u001b[0;32m     54\u001b[0m target_tensors \u001b[39m=\u001b[39m [torch\u001b[39m.\u001b[39mFloatTensor(tgt)\u001b[39m.\u001b[39mto(device) \u001b[39mfor\u001b[39;00m tgt \u001b[39min\u001b[39;00m sorted_tgt]\n\u001b[0;32m     55\u001b[0m padded_input \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mnn\u001b[39m.\u001b[39mutils\u001b[39m.\u001b[39mrnn\u001b[39m.\u001b[39mpad_sequence(input_tensors)\n",
      "\u001b[1;31mRuntimeError\u001b[0m: CUDA error: device-side assert triggered\nCUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1.\nCompile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.\n"
     ]
    }
   ],
   "source": [
    "train_loss_list = []\n",
    "valid_loss_list = []\n",
    "CUDA_LAUNCH_BLOCKING=1\n",
    "for epoch in range(10):\n",
    "    print(\"nb of batch\", len(train_dataloader))\n",
    "    start_time = time.time()\n",
    "    train_loss = train(model, train_dataloader, optimizer, criterion, 1)\n",
    "    valid_loss = evaluate(model, valid_dataloader, criterion)\n",
    "\n",
    "    train_loss_list.append(train_loss)\n",
    "    valid_loss_list.append(valid_loss)\n",
    "    end_time = time.time()\n",
    "    \n",
    "    print(f'Epoch: {epoch+1:02} | Time: {end_time - start_time}s')\n",
    "    print(f'\\tTrain Loss: {train_loss}')\n",
    "    print(f'\\t Val. Loss: {valid_loss}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x16b75b45a50>]"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_loss_list, color=\"blue\")\n",
    "plt.plot(valid_loss_list, color=\"orange\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.10.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}