trajectory-prediction.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zdUd1-SVvoWp",
        "outputId": "4a3c8936-fd23-4f16-9e5f-d0d4abaedbaa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "\"\"\"\n",
        "UNCOMMENT FOR RUNNING IN COLAB ENVIRONMENT\n",
        "\"\"\"\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "Mls0lxnJvkp5"
      },
      "outputs": [],
      "source": [
        "# importing libraries\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch.autograd import Variable\n",
        "from torch.utils.data import Dataset\n",
        "from torch.nn.functional import softmax\n",
        "\n",
        "import os\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import random\n",
        "import scipy.spatial\n",
        "import scipy.io\n",
        "from copy import deepcopy\n",
        "import math\n",
        "from tqdm import tqdm \n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "222TSJ-uvkp9"
      },
      "outputs": [],
      "source": [
        "class TFDataset(Dataset):\n",
        "    \"\"\"\n",
        "    Class to create the torch Dataset object\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self,data,name,mean,std):\n",
        "        super(TFDataset,self).__init__()\n",
        "\n",
        "        self.data=data  # dictionary\n",
        "        self.name=name  # string\n",
        "\n",
        "        self.mean= mean # numpy (4,)\n",
        "        self.std = std  # numpy (4,)\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.data['src'].shape[0]\n",
        "\n",
        "\n",
        "    def __getitem__(self,index):\n",
        "        return {'src':torch.Tensor(self.data['src'][index]),\n",
        "                'trg':torch.Tensor(self.data['trg'][index]),\n",
        "                'frames':self.data['frames'][index],\n",
        "                'seq_start':self.data['seq_start'][index],\n",
        "                'dataset':self.data['dataset'][index],\n",
        "                'peds': self.data['peds'][index],\n",
        "                }\n",
        "\n",
        "\n",
        "def create_dataset(dataset_folder, dataset_name, val_size, gt, horizon, delim=\"\\t\", train=True, eval=False, verbose=False):\n",
        "    \"\"\"\n",
        "    Function to import .txt file and create the torch Dataset.\n",
        "    The function splits the dataset into train, val and test.\n",
        "\n",
        "    INPUT:\n",
        "    dataset_folder - (str) path to the folder containing the dataset\n",
        "    dataset_name - (str) name of the dataset\n",
        "    val_size - (int) number of datapoints in validation set\n",
        "    gt - (int) size of the input observations to be passed to the encoder\n",
        "    horizon - (int) size of the input observations to be passed to the decoder\n",
        "    delim - (str) delimeter needed to read the dataset csv file\n",
        "    train - (bool) boolean indicating if training dataset needs to be created. Default value = True\n",
        "    eval - (bool) boolean indicating if testing dataset needs to be created. Default value = False\n",
        "    verbose - (bool) boolean indicating if printing in required during code execution. Default value = False\n",
        "\n",
        "    OUTPUT:\n",
        "\n",
        "    object of the TFDataset class\n",
        "    \"\"\"\n",
        "\n",
        "    # finding the path to the required datasets\n",
        "    if train==True:\n",
        "        datasets_list = os.listdir(os.path.join(dataset_folder,dataset_name, \"train\"))\n",
        "        full_dt_folder=os.path.join(dataset_folder,dataset_name, \"train\")\n",
        "    if train==False and eval==False:\n",
        "        datasets_list = os.listdir(os.path.join(dataset_folder, dataset_name, \"val\"))\n",
        "        full_dt_folder = os.path.join(dataset_folder, dataset_name, \"val\")\n",
        "    # if train==False and eval==True:\n",
        "    #     datasets_list = os.listdir(os.path.join(dataset_folder, dataset_name, \"test\"))\n",
        "    #     full_dt_folder = os.path.join(dataset_folder, dataset_name, \"test\")\n",
        "\n",
        "\n",
        "    datasets_list=datasets_list\n",
        "    data={}\n",
        "    data_src=[]\n",
        "    data_trg=[]\n",
        "    data_seq_start=[]\n",
        "    data_frames=[]\n",
        "    data_dt=[]\n",
        "    data_peds=[]\n",
        "\n",
        "    val_src = []\n",
        "    val_trg = []\n",
        "    val_seq_start = []\n",
        "    val_frames = []\n",
        "    val_dt = []\n",
        "    val_peds=[]\n",
        "\n",
        "    if verbose:\n",
        "        print(\"start loading dataset\")\n",
        "        print(\"validation set size -> %i\"%(val_size))\n",
        "\n",
        "\n",
        "    # enumerating through all the .txt files in the required dataset folder\n",
        "    for i_dt, dt in enumerate(datasets_list):\n",
        "        if verbose:\n",
        "            print(\"%03i / %03i - loading %s\"%(i_dt+1,len(datasets_list),dt))\n",
        "        raw_data = pd.read_csv(os.path.join(full_dt_folder, dt), delimiter=delim,\n",
        "                                        names=[\"frame\", \"ped\", \"x\", \"y\"],usecols=[0,1,2,3],na_values=\"?\")\n",
        "\n",
        "        raw_data.sort_values(by=['frame','ped'], inplace=True)\n",
        "\n",
        "        inp,out,info=get_strided_data_clust(raw_data,gt,horizon,1)\n",
        "\n",
        "        dt_frames=info['frames']\n",
        "        dt_seq_start=info['seq_start']\n",
        "        dt_dataset=np.array([i_dt]).repeat(inp.shape[0])\n",
        "        dt_peds=info['peds']\n",
        "\n",
        "\n",
        "        # creating validation data only if the training data is > 2.5 * validation data size\n",
        "        if val_size>0 and inp.shape[0]>val_size*2.5:\n",
        "            if verbose:\n",
        "                print(\"created validation from %s\" % (dt))\n",
        "            k = random.sample(np.arange(inp.shape[0]).tolist(), val_size)\n",
        "            val_src.append(inp[k, :, :])\n",
        "            val_trg.append(out[k, :, :])\n",
        "            val_seq_start.append(dt_seq_start[k, :, :])\n",
        "            val_frames.append(dt_frames[k, :])\n",
        "            val_dt.append(dt_dataset[k])\n",
        "            val_peds.append(dt_peds[k])\n",
        "            inp = np.delete(inp, k, 0)\n",
        "            out = np.delete(out, k, 0)\n",
        "            dt_frames = np.delete(dt_frames, k, 0)\n",
        "            dt_seq_start = np.delete(dt_seq_start, k, 0)\n",
        "            dt_dataset = np.delete(dt_dataset, k, 0)\n",
        "            dt_peds = np.delete(dt_peds,k,0)\n",
        "        elif val_size>0:\n",
        "            if verbose:\n",
        "                print(\"could not create validation from %s, size -> %i\" % (dt,inp.shape[0]))\n",
        "\n",
        "        data_src.append(inp)                # (num_datapoints in current dataset file, gt_size, 4)\n",
        "        data_trg.append(out)                # (num_datapoints in current dataset file, horizon, 4)\n",
        "        data_seq_start.append(dt_seq_start) # (num_datapoints in current dataset file, 1, 2)\n",
        "        data_frames.append(dt_frames)       # (num_datapoints in current dataset file, 20)\n",
        "        data_dt.append(dt_dataset)          # (num_datapoints in current dataset file,) data set ids\n",
        "        data_peds.append(dt_peds)           # (num_datapoints in current dataset file,) pedestrian ids\n",
        "\n",
        "\n",
        "\n",
        "    # concatenating all the dataset files in the current dataset folder\n",
        "    data['src'] = np.concatenate(data_src, 0)\n",
        "    data['trg'] = np.concatenate(data_trg, 0)\n",
        "    data['seq_start'] = np.concatenate(data_seq_start, 0)\n",
        "    data['frames'] = np.concatenate(data_frames, 0)\n",
        "    data['dataset'] = np.concatenate(data_dt, 0)\n",
        "    data['peds'] = np.concatenate(data_peds, 0)\n",
        "    data['dataset_name'] = datasets_list\n",
        "\n",
        "    # finding the mean and standard deviation of x and y positions of all datapoints\n",
        "    mean= data['src'].mean((0,1))\n",
        "    std= data['src'].std((0,1))\n",
        "\n",
        "    # concatenate all validation dataset files\n",
        "    if val_size>0:\n",
        "        data_val={}\n",
        "        data_val['src']=np.concatenate(val_src,0)\n",
        "        data_val['trg'] = np.concatenate(val_trg, 0)\n",
        "        data_val['seq_start'] = np.concatenate(val_seq_start, 0)\n",
        "        data_val['frames'] = np.concatenate(val_frames, 0)\n",
        "        data_val['dataset'] = np.concatenate(val_dt, 0)\n",
        "        data_val['peds'] = np.concatenate(val_peds, 0)\n",
        "\n",
        "        return TFDataset(data, \"train\", mean, std), TFDataset(data_val, \"validation\", mean, std)\n",
        "\n",
        "    return TFDataset(data, \"train\", mean, std), None\n",
        "\n",
        "\n",
        "def get_strided_data_clust(dt, gt_size, horizon, step):\n",
        "    \"\"\"\n",
        "    splitting the data into clusters of a size (gt_size + horizon)\n",
        "\n",
        "    INPUT:\n",
        "    dt - (pandas df) dataframe for the dataset\n",
        "    gt_size - (int) size of the input observations to be passed to the encoder\n",
        "    horizon - (int) size of the input observations to be passed to the decoder \n",
        "    step - (int) integer indicating the stride/window shift\n",
        "\n",
        "    OUTPUT:\n",
        "    inp - (numpy arrays) input data to encoder. Shape = (num_datapoints, gt_size, 4)\n",
        "    out - (numpy arrays) input data to decoder. Shape = (num_datapoints, horizon, 4)\n",
        "    info - (dictionary) meta for dataset\n",
        "    \"\"\"\n",
        "\n",
        "    inp_te = []\n",
        "    dtt = dt.astype(np.float32)\n",
        "    raw_data = dtt\n",
        "\n",
        "    ped = raw_data.ped.unique()\n",
        "    frame=[]\n",
        "    ped_ids=[]\n",
        "\n",
        "    # clustering the dataset by looping through all unique pedestrian ID's\n",
        "    for p in ped:\n",
        "        for i in range(1+(raw_data[raw_data.ped == p].shape[0] - gt_size - horizon) // step):\n",
        "            frame.append(dt[dt.ped == p].iloc[i * step:i * step + gt_size + horizon, [0]].values.squeeze())\n",
        "            # print(\"%i,%i,%i\" % (i * 4, i * 4 + gt_size, i * 4 + gt_size + horizon))\n",
        "            inp_te.append(raw_data[raw_data.ped == p].iloc[i * step:i * step + gt_size + horizon, 2:4].values)\n",
        "            ped_ids.append(p)\n",
        "\n",
        "    frames=np.stack(frame)\n",
        "    inp_te_np = np.stack(inp_te)\n",
        "    ped_ids=np.stack(ped_ids)\n",
        "\n",
        "    # calculating the speed of the pedestrian between 2 frames\n",
        "    inp_speed = np.concatenate((np.zeros((inp_te_np.shape[0],1,2)),inp_te_np[:,1:,0:2] - inp_te_np[:, :-1, 0:2]),1)\n",
        "\n",
        "    # concatenating position and speed information\n",
        "    inp_norm=np.concatenate((inp_te_np,inp_speed),2)\n",
        "\n",
        "    inp_mean=np.zeros(4)\n",
        "    inp_std=np.ones(4)\n",
        "\n",
        "    inp = inp_norm[:,:gt_size]\n",
        "    out = inp_norm[:,gt_size:]\n",
        "\n",
        "    # seq_start - starting x,y position in every window\n",
        "    info = {'mean': inp_mean, 'std': inp_std, 'seq_start': inp_te_np[:, 0:1, :].copy(),'frames':frames,'peds':ped_ids}\n",
        "\n",
        "    return inp, out, info\n",
        "\n",
        "\n",
        "def distance_metrics(target, preds):\n",
        "    \"\"\"\n",
        "    Function to calculate MAD (mean average displacement) and FAD (final average displacement)\n",
        "\n",
        "    INPUT:\n",
        "    target - (numpy array) ground truth values for pedestrian positions\n",
        "    preds - (numpy array) predicted values for pedestrian positions\n",
        "\n",
        "    OUTPUT:\n",
        "    mad - (numpy array) MAD value\n",
        "    fad - (numpy array) FAD value\n",
        "    errors - (numpy array) error value\n",
        "    \"\"\"\n",
        "    \n",
        "    errors = np.zeros(preds.shape[:-1])\n",
        "    for i in range(errors.shape[0]):\n",
        "        for j in range(errors.shape[1]):\n",
        "            errors[i, j] = scipy.spatial.distance.euclidean(target[i, j], preds[i, j])\n",
        "\n",
        "    mad = errors.mean()\n",
        "    fad = errors[:,-1].mean()\n",
        "\n",
        "    return mad, fad, errors"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "j5T2o-3WvkqA"
      },
      "outputs": [],
      "source": [
        "def subsequent_mask(size):\n",
        "    \"\"\"\n",
        "    Function to compute the mask used in attention layer of decoder\n",
        "\n",
        "    INPUT:\n",
        "    size - (int) horizon size\n",
        "\n",
        "    OUTPUT:\n",
        "    mask - (torch tensor) boolean array to mask out the data in decoder\n",
        "    \"\"\"\n",
        "\n",
        "    attn_shape = (1, size, size)\n",
        "    mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')\n",
        "    mask = torch.from_numpy(mask) == 0\n",
        "\n",
        "    return mask\n",
        "\n",
        "\n",
        "def attention(Q, K, V, mask=None, dropout=None):\n",
        "    \"\"\"\n",
        "    Function to compute the attention from given Q, K and V values \n",
        "\n",
        "    INPUT:\n",
        "    Q - (torch tensor) query for the transformer. Shape = (B, H, N, C)\n",
        "    K - (torch tensor) keys for the transformer. Shape = (B, H, N, C)\n",
        "    V - (torch tensor) values for the transformer. Shape = (B, H, N, C) \n",
        "    mask - (torch tensor) mask for decoder multi head attention layer\n",
        "    dropout - (float) dropout percentage\n",
        "\n",
        "    OUTPUT:\n",
        "    attn_output - (torch tensor) output of the multi head attention layer. Shape = (B, H, N, C)\n",
        "    \"\"\"\n",
        "\n",
        "    # finding the embedding size\n",
        "    new_emb_size = Q.shape[0]\n",
        "    # calculating attention scores\n",
        "    scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(new_emb_size)\n",
        "\n",
        "    # applying mask on the attention\n",
        "    if mask is not None:\n",
        "        scores = scores.masked_fill_(mask == 0, -1e9)\n",
        "\n",
        "    # applying softmax layer and calculating prob of attention\n",
        "    p_attn = softmax(scores, dim=-1)\n",
        "\n",
        "    # applying dropout\n",
        "    if dropout is not None:\n",
        "        p_attn = dropout(p_attn)\n",
        "    \n",
        "    # multiplying the prob of attentiom with Values (V)  \n",
        "    attn_output = torch.matmul(p_attn, V)\n",
        "\n",
        "    return attn_output\n",
        "\n",
        "def cosine_scheduler(t, eta_max, T):\n",
        "    \"\"\"\n",
        "    Function to implement cosine scheduler\n",
        "    \"\"\"\n",
        "\n",
        "    T_0 = T/5\n",
        "\n",
        "    if t <= T_0:\n",
        "        lr = 1e-6 + ((t/T_0) * eta_max)\n",
        "    else:\n",
        "        lr = 1e-8 + (eta_max * np.cos((np.pi/2)*((t-T_0)/(T-T_0))))\n",
        "    \n",
        "    return lr\n",
        "\n",
        "\n",
        "def learning_rate_finder(tf_model, optimizer, train_loader, iterations, device, mean, std, increment=1.1):\n",
        "    \"\"\"\n",
        "    Function to perform the \"learning rate finder\" algorithm.\n",
        "    \"\"\"\n",
        "\n",
        "    # initilizing array to store training loss of each minibatch\n",
        "    train_loss = []\n",
        "    # initializing the array to store the learning rates\n",
        "    learning_rates = []\n",
        "\n",
        "    for idx, data in enumerate(train_loader):\n",
        "        # getting encoder input data\n",
        "        enc_input = (data['src'][:,1:,2:4].to(device)-mean.to(device))/std.to(device)\n",
        "\n",
        "        # getting decoder input data\n",
        "        target = (data['trg'][:,:-1,2:4].to(device)-mean.to(device))/std.to(device)\n",
        "        target_append = torch.zeros((target.shape[0],target.shape[1],1)).to(device)\n",
        "        target = torch.cat((target,target_append),-1)\n",
        "        start_of_seq = torch.Tensor([0, 0, 1]).unsqueeze(0).unsqueeze(1).repeat(target.shape[0],1,1).to(device)\n",
        "        dec_input = torch.cat((start_of_seq, target), 1)\n",
        "\n",
        "        # getting masks for decoder\n",
        "        dec_source_mask = torch.ones((enc_input.shape[0], 1,enc_input.shape[1])).to(device)\n",
        "        dec_target_mask = subsequent_mask(dec_input.shape[1]).repeat(dec_input.shape[0],1,1).to(device)\n",
        "\n",
        "        # forward pass \n",
        "        optimizer.zero_grad()\n",
        "        predictions = tf_model.forward(enc_input, dec_input, dec_source_mask, dec_target_mask)\n",
        "\n",
        "        # calculating loss using pairwise distance of all predictions\n",
        "        loss = F.pairwise_distance(predictions[:, :,0:2].contiguous().view(-1, 2),\n",
        "                                    ((data['trg'][:, :, 2:4].to(device)-mean.to(device))/std.to(device)).\\\n",
        "                                    contiguous().view(-1, 2).to(device)).mean() + \\\n",
        "                                    torch.mean(torch.abs(predictions[:,:,2]))\n",
        "        train_loss.append(loss.item())             \n",
        "        # changing the learning rate \n",
        "        for param in optimizer.param_groups:\n",
        "            learning_rates.append(param['lr'])\n",
        "            param['lr'] *= increment\n",
        "        \n",
        "        # updating weights\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        if idx == iterations:\n",
        "            break\n",
        "\n",
        "    return train_loss, learning_rates"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "8kf63Qi4vkqA"
      },
      "outputs": [],
      "source": [
        "class MultiHeadAttention(nn.Module):\n",
        "    \"\"\"\n",
        "    Class to create the multi head attention layer for \n",
        "    encoder and decoder\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, num_heads, emb_size, dropout=0.1):\n",
        "        \"\"\"\n",
        "        Class constructor\n",
        "\n",
        "        INPUT:\n",
        "        num_head - (int) number of heads in multi head attention layer\n",
        "        emb_size - (int) embedding size of the data\n",
        "        dropout - (float) dropout percentage. Default value = 0.1\n",
        "        \"\"\"\n",
        "        super(MultiHeadAttention, self).__init__()\n",
        "\n",
        "        # making sure that the embedding size is divisible by the number\n",
        "        # of heads\n",
        "        assert emb_size % num_heads == 0\n",
        "\n",
        "        # caching values\n",
        "        self.emb_size = emb_size\n",
        "        self.num_heads = num_heads\n",
        "\n",
        "        # creating a single MLP layer for queries, keys and values\n",
        "        self.q_linear = nn.Linear(emb_size, emb_size)\n",
        "        self.k_linear = nn.Linear(emb_size, emb_size)\n",
        "        self.v_linear = nn.Linear(emb_size, emb_size)\n",
        "        # creating MLP layer for post attention\n",
        "        self.post_att = nn.Linear(emb_size, emb_size)\n",
        "\n",
        "        # creating dropout layer\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "    \n",
        "    def forward(self, Q, K, V, mask=None):\n",
        "        \"\"\"\n",
        "        forward function for MultiHeadAttention\n",
        "\n",
        "        INPUT:\n",
        "        Q - (torch tensor) query for the transformer. Shape = (B, N, C)\n",
        "        K - (torch tensor) keys for the transformer. Shape = (B, N, C)\n",
        "        V - (torch tensor) values for the transformer. Shape = (B, N, C)\n",
        "        mask - (torch tensor) mask for decoder multi head attention layer\n",
        "\n",
        "        OUTPUT:\n",
        "        att_output - (torch tensor) output of the multi head attention layer. Shape = (B, N, C)\n",
        "        \"\"\"\n",
        "\n",
        "        if mask is not None:\n",
        "            # Same mask applied to all h heads.\n",
        "            mask = mask.unsqueeze(1)\n",
        "\n",
        "        # passing the Q, K, and V through 1 layer MLP\n",
        "        Q, K, V = self.q_linear(Q), self.k_linear(K), self.v_linear(V)  # Shape = (B, N, C)\n",
        "\n",
        "        # splitting Q, K and V based on num_heads\n",
        "        batch_size = Q.shape[0]\n",
        "        new_emb_size = self.emb_size // self.num_heads\n",
        "\n",
        "        Q = Q.reshape(batch_size, -1, self.num_heads, new_emb_size)     # Shape = (B, N, H, C//H)\n",
        "        K = K.reshape(batch_size, -1, self.num_heads, new_emb_size)     # Shape = (B, N, H, C//H)\n",
        "        V = V.reshape(batch_size, -1, self.num_heads, new_emb_size)     # Shape = (B, N, H, C//H)\n",
        "\n",
        "        # permuting the dimensions of Q, K and V\n",
        "        Q = Q.permute(0,2,1,3)                                          # Shape = (B, H, N, C//H)\n",
        "        K = K.permute(0,2,1,3)                                          # Shape = (B, H, N, C//H)\n",
        "        V = V.permute(0,2,1,3)                                          # Shape = (B, H, N, C//H)\n",
        "\n",
        "        # calculating attention\n",
        "        attn_output = attention(Q, K, V, mask, self.dropout)            # Shape = (B, H, N, C//H)\n",
        "\n",
        "        # permuting the dimensions of attn_output and collapsing \n",
        "        # the num_heads dimension\n",
        "        attn_output = attn_output.permute(0,2,1,3)                      # Shape = (B, N, H, C//H)\n",
        "        attn_output = attn_output.reshape(batch_size, -1, self.emb_size)# Shape = (B, N, C)\n",
        "\n",
        "        # applying linear layer to output of attention layer\n",
        "        attn_output = self.post_att(attn_output)                        # Shape = (B, N, C)\n",
        "\n",
        "        return attn_output\n",
        "\n",
        "class EncoderLayer(nn.Module):\n",
        "    \"\"\"\n",
        "    class for a single encoder layer\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, emb_size, num_heads, ff_hidden_size, dropout=0.1):\n",
        "        \"\"\"\n",
        "        class initializer\n",
        "\n",
        "        INPUT:\n",
        "        emb_size - (int) embedding size of the data\n",
        "        num_heads - (int) number of heads in multi head attention layer\n",
        "        ff_hidden_size - (int) size of the hidden layer for the feed forward network\n",
        "        dropout - (float) dropout percentage. Default value = 0.1\n",
        "        \"\"\"\n",
        "        super(EncoderLayer, self).__init__()\n",
        "\n",
        "        # creating dropout layer\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "        # creating normalization layer for attention module\n",
        "        self.norm_attn = nn.LayerNorm(emb_size)\n",
        "        # creating normalization layer for feed forward layer\n",
        "        self.norm_ff = nn.LayerNorm(emb_size)\n",
        "\n",
        "        # creating object for multi head attention layer\n",
        "        self.attn = MultiHeadAttention(num_heads, emb_size, dropout)\n",
        "\n",
        "        # creating feed forward layer\n",
        "        self.ff = nn.Sequential(nn.Linear(emb_size, ff_hidden_size),\n",
        "                                nn.ReLU(), \n",
        "                                nn.Dropout(dropout),\n",
        "                                nn.Linear(ff_hidden_size, emb_size))\n",
        "    \n",
        "    def forward(self, x):\n",
        "        \"\"\"\n",
        "        forward pass through one encoder layer\n",
        "\n",
        "        INPUT:\n",
        "        x - (torch tensor) input data to the encoder layer. Shape = (B, N, C)\n",
        "\n",
        "        OUTPUT:\n",
        "        x - (torch tensor) output of the encoder layer. Shape = (B, N, C)\n",
        "        \"\"\"\n",
        "\n",
        "        # sublayer 1: Input -> LayerNorm -> MultiHeadAttention -> Dropout -> ResidualAdd\n",
        "        x = x + self.dropout(self.attn.forward(self.norm_attn(x), self.norm_attn(x), self.norm_attn(x)))    # Shape = (B, N ,C)\n",
        "\n",
        "        # sublayer 2: Input -> LayerNorm -> FFN -> Dropout -> ResidualAdd\n",
        "        x = x + self.dropout(self.ff(self.norm_ff(x)))                                                      # Shape = (B, N ,C)\n",
        "\n",
        "        return x\n",
        "\n",
        "class Encoder(nn.Module):\n",
        "    \"\"\"\n",
        "    class for implementing a stack of n EncoderLayers\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, emb_size, num_heads, ff_hidden_size, n, dropout=0.1):\n",
        "        \"\"\"\n",
        "        class initializer\n",
        "\n",
        "        INPUT:\n",
        "        emb_size - (int) embedding size of the data\n",
        "        num_heads - (int) number of heads in multi head attention layer\n",
        "        ff_hidden_size - (int) size of the hidden layer for the feed forward network\n",
        "        n - (int) number of encoder layers \n",
        "        dropout - (float) dropout percentage. Default value = 0.1\n",
        "        \"\"\"\n",
        "        super(Encoder, self).__init__()\n",
        "        \n",
        "        # creating object for 1 encoder layer\n",
        "        encoder_layer_obj = EncoderLayer(emb_size, num_heads, ff_hidden_size, dropout)\n",
        "        # creating a stack of n encoder layers\n",
        "        self.enc_layers = nn.ModuleList([deepcopy(encoder_layer_obj) for _ in range(n)])\n",
        "\n",
        "        # defining LayerNorm for last layer of encoder\n",
        "        self.norm = nn.LayerNorm(emb_size)\n",
        "\n",
        "    def forward(self, x):\n",
        "        \"\"\"\n",
        "        forward function to implement one pass through all layers of encoder\n",
        "\n",
        "        INPUT:\n",
        "        x - (torch tensor). input data. Shape = (B, N, C)\n",
        "\n",
        "        OUTPUT:\n",
        "        x - (torch tensor). output of the encoder block. Shape = (B, N, C)\n",
        "        \"\"\"\n",
        "\n",
        "        for layer in self.enc_layers:\n",
        "            x = layer.forward(x)               # Shape = (B, N, C)\n",
        "        \n",
        "        x = self.norm(x)                        # Shape = (B, N, C)\n",
        "\n",
        "        return x\n",
        "\n",
        "class DecoderLayer(nn.Module):\n",
        "    \"\"\"\n",
        "    class for implementing a single decoder layer\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, emb_size, num_heads, ff_hidden_size, dropout=0.1):\n",
        "        \"\"\"\n",
        "        class initializer\n",
        "\n",
        "        INPUT:\n",
        "        emb_size - (int) embedding size of the data\n",
        "        num_heads - (int) number of heads in multi head attention layer\n",
        "        ff_hidden_size - (int) size of the hidden layer for the feed forward network\n",
        "        dropout - (float) dropout percentage. Default value = 0.1\n",
        "        \"\"\"\n",
        "        super(DecoderLayer, self).__init__()\n",
        "\n",
        "        # creating dropout layer\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "        # creating normalization layer for self attention module\n",
        "        self.norm_attn = nn.LayerNorm(emb_size)\n",
        "        # creating normalization layer for encoder-decoder attention module\n",
        "        self.norm_enc_dec = nn.LayerNorm(emb_size)\n",
        "        # creating normalization layer for feed forward layer\n",
        "        self.norm_ff = nn.LayerNorm(emb_size)\n",
        "\n",
        "        # creating object for multi head self attention layer\n",
        "        self.attn = MultiHeadAttention(num_heads, emb_size, dropout)\n",
        "        # creating object for multi head encoder-decoder attention layer\n",
        "        self.enc_dec_attn = MultiHeadAttention(num_heads, emb_size, dropout)\n",
        "\n",
        "        # creating feed forward layer\n",
        "        self.ff = nn.Sequential(nn.Linear(emb_size, ff_hidden_size),\n",
        "                                nn.ReLU(), \n",
        "                                nn.Dropout(dropout),\n",
        "                                nn.Linear(ff_hidden_size, emb_size))\n",
        "\n",
        "    def forward(self, x, enc_output, source_mask, target_mask):\n",
        "        \"\"\"\n",
        "        forward pass through one decoder layer\n",
        "\n",
        "        INPUT:\n",
        "        x - (torch tensor) input data to the decoder layer. Shape = (B, N, C)\n",
        "        enc_output - (torch tensor) output of the encoder block. Shape = (B, N, C)\n",
        "        source_mask - (torch tensor) mask for encoder-decoder attention layer\n",
        "        target_mask - (torch tensor) mask for decoder self attention layer\n",
        "\n",
        "        OUTPUT:\n",
        "        x - (torch tensor) output of the decoder layer. Shape = (B, N ,C)\n",
        "        \"\"\"\n",
        "\n",
        "        # sublayer 1: Input -> LayerNorm -> MultiHeadAttention -> Dropout -> ResidualAdd\n",
        "        x = x + self.dropout(self.attn.forward(self.norm_attn(x),\\\n",
        "            self.norm_attn(x),self.norm_attn(x), target_mask))                          # Shape = (B, N ,C)\n",
        "        \n",
        "        # sublayer 2: Input -> LayerNorm -> EncoderDecoderAttention -> Dropout -> ResidualAdd\n",
        "        x = x + self.dropout(self.enc_dec_attn.forward(self.norm_enc_dec(x),\\\n",
        "            self.norm_enc_dec(enc_output),self.norm_enc_dec(enc_output), source_mask))  # Shape = (B, N ,C)\n",
        "        \n",
        "        # sublayer 3: Input -> LayerNorm -> FFN -> Dropout -> ResidualAdd\n",
        "        x = x + self.dropout(self.ff(self.norm_ff(x)))                                  # Shape = (B, N ,C)\n",
        "\n",
        "        return x\n",
        "        \n",
        "class Decoder(nn.Module):\n",
        "    \"\"\"\n",
        "    class for implementing stack of n decoder layers\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, emb_size, num_heads, ff_hidden_size, n, dropout=0.1):\n",
        "        \"\"\"\n",
        "        class initializer\n",
        "\n",
        "        INPUT:\n",
        "        emb_size - (int) embedding size of the data\n",
        "        num_heads - (int) number of heads in multi head attention layer\n",
        "        ff_hidden_size - (int) size of the hidden layer for the feed forward network\n",
        "        n - (int) number of encoder layers \n",
        "        dropout - (float) dropout percentage. Default value = 0.1      \n",
        "        \"\"\"\n",
        "        super(Decoder, self).__init__()\n",
        "\n",
        "        # creating object for 1 decoder layer\n",
        "        decoder_obj = DecoderLayer(emb_size, num_heads, ff_hidden_size, dropout)\n",
        "        # creating stack of n decoder layers\n",
        "        self.dec_layers = nn.ModuleList([deepcopy(decoder_obj) for _ in range(n)])\n",
        "\n",
        "        # defining LayerNorm for decoder end\n",
        "        self.norm = nn.LayerNorm(emb_size)\n",
        "\n",
        "    def forward(self, x, enc_output, source_mask, target_mask):\n",
        "        \"\"\"\n",
        "        x - (torch tensor) input data to the decoder block. Shape = (B, N, C)\n",
        "        enc_output - (torch tensor) output of the encoder block. Shape = (B, N, C)\n",
        "        source_mask - (torch tensor) mask for encoder-decoder attention layer\n",
        "        target_mask - (torch tensor) mask for decoder self attention layer\n",
        "\n",
        "        OUTPUT:\n",
        "        x - (torch tensor) output of the decoder layer. Shape = (B, N ,C)\n",
        "        \"\"\"\n",
        "\n",
        "        for layer in self.dec_layers:\n",
        "            x = layer.forward(x, enc_output, source_mask, target_mask)      # Shape = (B, N, C)\n",
        "        \n",
        "        x = self.norm(x)                                                    # Shape = (B, N, C)\n",
        "\n",
        "        return x\n",
        "\n",
        "class PositionalEncoding(nn.Module):\n",
        "    \"\"\"\n",
        "    class to implement positional encoding for encoder and decoder input data\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, emb_size, dropout=0.1, max_len=5000):\n",
        "        \"\"\"\n",
        "        class initializer\n",
        "\n",
        "        INPUT:\n",
        "        emb_size - (int) size of the embedding\n",
        "        dropout - (float) dropout percentage. Default value = 0.1\n",
        "        max_len - (int) max positional length. Default value = 5000\n",
        "        \"\"\"\n",
        "        super(PositionalEncoding, self).__init__()\n",
        "\n",
        "        # defining the dropout layer\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "        # Compute the positional encodings once in log space.\n",
        "        pe = torch.zeros(max_len, emb_size)\n",
        "        position = torch.arange(0, max_len).unsqueeze(1).float()\n",
        "        div_term = torch.exp(torch.arange(0, emb_size, 2).float() * -(math.log(10000.0) / emb_size))\n",
        "        pe[:, 0::2] = torch.sin(position * div_term)\n",
        "        pe[:, 1::2] = torch.cos(position * div_term)\n",
        "        pe = pe.unsqueeze(0)\n",
        "        self.register_buffer('pe', pe)\n",
        "\n",
        "    def forward(self, x):\n",
        "        \"\"\"\n",
        "        forward pass to generate positional embeddings\n",
        "\n",
        "        INPUT:\n",
        "        x - (torch tensor) embedded data. Shape = (B, N, C) \n",
        "\n",
        "        OUTPUT:\n",
        "        x - (torch tensor) positional embedded data. Shape = (B, N, C) \n",
        "        \"\"\"\n",
        "\n",
        "        x = x + Variable(self.pe[:, :x.size(1)], requires_grad=False)\n",
        "        x = self.dropout(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "class Embeddings(nn.Module):\n",
        "    \"\"\"\n",
        "    class to generate the embeddings for encoder and decoder input data\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, input_size, emb_size):\n",
        "        \"\"\"\n",
        "        class initializer\n",
        "\n",
        "        INPUT:\n",
        "        input_size - (int) size of the input data\n",
        "        emb_size - (int) size of the embedding\n",
        "        \"\"\"\n",
        "        super(Embeddings, self).__init__()\n",
        "\n",
        "        # caching values\n",
        "        self.emb_size = emb_size\n",
        "\n",
        "        # creating liner layer for embedding input data\n",
        "        self.linear_embd = nn.Linear(input_size, emb_size)\n",
        "\n",
        "        # creating object for positional encoding\n",
        "        self.pos_encoding = PositionalEncoding(emb_size, dropout=0.1, max_len=5000)\n",
        "    \n",
        "    def forward(self, x):\n",
        "        \"\"\"\n",
        "        forward pass to generate input embeddings\n",
        "\n",
        "        INPUT:\n",
        "        x - (torch tensor) input data. Shape = (B, N, input_dimension)\n",
        "\n",
        "        OUTPUT:\n",
        "        x - (torch tensor) embedded data. Shape = (B, N, C)\n",
        "        \"\"\"\n",
        "\n",
        "        # creating embeddings for input data\n",
        "        x = self.linear_embd(x) * math.sqrt(self.emb_size)     # Shape = (B, N, C)\n",
        "        # incorporating positional embeddings\n",
        "        x = self.pos_encoding.forward(x)\n",
        "\n",
        "        return x\n",
        "\n",
        "class OutputGenerator(nn.Module):\n",
        "    \"\"\"\n",
        "    class to generate the output embeddings from the transformer's output\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, emb_size, output_size):\n",
        "        \"\"\"\n",
        "        class initializer\n",
        "\n",
        "        INPUT:\n",
        "        output_size - (int) size of the output data\n",
        "        emb_size - (int) size of the embedding\n",
        "        \"\"\"\n",
        "        super(OutputGenerator, self).__init__()\n",
        "\n",
        "        # creating liner layer for embedding input data\n",
        "        self.output_gen = nn.Linear(emb_size, output_size)\n",
        "    \n",
        "    def forward(self, x):\n",
        "        \"\"\"\n",
        "        forward pass to generate the output data\n",
        "\n",
        "        INPUT:\n",
        "        x - (torch tensor) input data from transformer. Shape = (B, N, output_dimension)\n",
        "\n",
        "        OUTPUT:\n",
        "        x - (torch tensor) output data. Shape = (B, N, output_size)\n",
        "        \"\"\"\n",
        "\n",
        "        x = self.output_gen(x)     # Shape = (B, N, output_size) \n",
        "\n",
        "        return x\n",
        "\n",
        "class TFModel(nn.Module):\n",
        "    \"\"\"\n",
        "    class to generate the complete transformer architecture\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, encoder_ip_size, decoder_ip_size, model_op_size, emb_size, \\\n",
        "                num_heads, ff_hidden_size, n, dropout=0.1):\n",
        "        \"\"\"\n",
        "        class initializer\n",
        "\n",
        "        INPUT:\n",
        "        encoder_ip_size - (int) dimension of the encoder input\n",
        "        decoder_ip_size - (int) dimension of the decoder input\n",
        "        model_op_size - (int) dimension of model's output\n",
        "        emb_size - (int) data embedding size for encoder and decoder\n",
        "        num_heads - (int) number of heads in multi head attention layer\n",
        "        ff_hidden_size - (int) size of the hidden layer for the feed forward network\n",
        "        n - (int) number of encoder layers \n",
        "        dropout - (float) dropout percentage. Default value = 0.1\n",
        "        \"\"\"\n",
        "        super(TFModel, self).__init__()\n",
        "\n",
        "        # creating embeddings for encoder input\n",
        "        self.encoder_embedding = Embeddings(encoder_ip_size, emb_size)\n",
        "        # creating embeddings for decoder input\n",
        "        self.decoder_embeddings= Embeddings(decoder_ip_size, emb_size)\n",
        "        \n",
        "        # creating encoder block\n",
        "        self.encoder_block = Encoder(emb_size, num_heads, ff_hidden_size, n, dropout)\n",
        "        # creating decoder block\n",
        "        self.decoder_block = Decoder(emb_size, num_heads, ff_hidden_size, n, dropout)\n",
        "\n",
        "        # creating output generator\n",
        "        self.output_gen = OutputGenerator(emb_size, model_op_size)\n",
        "    \n",
        "    def forward(self, enc_input, dec_input, dec_source_mask, dec_target_mask):\n",
        "        \"\"\"\n",
        "        forward pass for the transformer model\n",
        "\n",
        "        INPUT:\n",
        "        enc_input - (torch tensot) input data to the encoder block. Shape = (B, N, encoder_ip_size)\n",
        "        dec_input - (torch tensor) input data to the decoder block. Shape = (B, N, decoder_ip_size)\n",
        "        enc_output - (torch tensor) output of the encoder block. Shape = (B, N, emb_size)\n",
        "        source_mask - (torch tensor) mask for encoder-decoder attention layer\n",
        "        target_mask - (torch tensor) mask for decoder self attention layer\n",
        "\n",
        "        OUTPUT:\n",
        "        model_output - (torch tensor) output of the model. Shape = (B, N, model_op_size)\n",
        "        \"\"\"\n",
        "\n",
        "        enc_embed = self.encoder_embedding.forward(enc_input)\n",
        "        encoder_output = self.encoder_block.forward(enc_embed)\n",
        "\n",
        "        dec_embed = self.decoder_embeddings.forward(dec_input)\n",
        "        decoder_output = self.decoder_block.forward(dec_embed, encoder_output, dec_source_mask, dec_target_mask)\n",
        "\n",
        "        model_output = self.output_gen.forward(decoder_output)\n",
        "\n",
        "        return model_output\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "65vv4xsRNMRV"
      },
      "outputs": [],
      "source": [
        "# defining model save location\n",
        "save_location = \"/content/drive/MyDrive/ESE_546_project/models\"\n",
        "# defining dataset locations\n",
        "dataset_folder = \"/content/drive/MyDrive/ESE_546_project/datasets\"\n",
        "dataset_name = \"raw\"\n",
        "# setting validation size. if val_size = 0, split percentage is 80-20\n",
        "val_size = 0\n",
        "# lenght of sequence given to encoder\n",
        "gt = 8\n",
        "# length of sequence given to decoder\n",
        "horizon = 12\n",
        "\n",
        "# creating torch datasets\n",
        "train_dataset, _ = create_dataset(dataset_folder, dataset_name, val_size, \\\n",
        "    gt, horizon, delim=\"\\t\", train=True)\n",
        "val_dataset, _ = create_dataset(dataset_folder, dataset_name, val_size, \\\n",
        "    gt, horizon, delim=\"\\t\", train=False)\n",
        "# test_dataset, _ = create_dataset(dataset_folder, dataset_name, val_size, \\\n",
        "#     gt, horizon, delim=\"\\t\", train=False, eval=True)\n",
        "\n",
        "# defining batch size\n",
        "batch_size = 64\n",
        "\n",
        "# creating torch dataloaders\n",
        "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size, shuffle=True, num_workers=0)\n",
        "val_loader = torch.utils.data.DataLoader(val_dataset, batch_size, shuffle=True, num_workers=0)\n",
        "# test_loader = torch.utils.data.DataLoader(test_dataset, batch_size, shuffle=False, num_workers=0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 317
        },
        "id": "G9_HSan1MioM",
        "outputId": "167d23e6-88c0-4177-e583-7181c8511239"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Value of eta max is: 0.0001\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# learning rate finder algorithm for finding eta max\n",
        "\n",
        "# performing training\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# creating model\n",
        "encoder_ip_size = 2\n",
        "decoder_ip_size = 3\n",
        "model_op_size = 3\n",
        "emb_size = 512\n",
        "num_heads = 8\n",
        "ff_hidden_size = 2048\n",
        "n = 6\n",
        "dropout=0.1\n",
        "\n",
        "tf_model = TFModel(encoder_ip_size, decoder_ip_size, model_op_size, emb_size, \\\n",
        "                num_heads, ff_hidden_size, n, dropout=0.1).to(device)\n",
        "\n",
        "# number of iterations for LRF\n",
        "iterations = 70\n",
        "\n",
        "# creating optimizer\n",
        "optimizer = torch.optim.SGD(tf_model.parameters(), lr=1e-4, momentum=0.9, weight_decay=1e-3, nesterov=True)\n",
        "# optimizer = torch.optim.Adam(tf_model.parameters(), lr=1e-4)\n",
        "\n",
        "# calculating the mean and standard deviation of velocities of the entire dataset\n",
        "mean=torch.cat((train_dataset[:]['src'][:,1:,2:4],train_dataset[:]['trg'][:,:,2:4]),1).mean((0,1))\n",
        "std=torch.cat((train_dataset[:]['src'][:,1:,2:4],train_dataset[:]['trg'][:,:,2:4]),1).std((0,1))\n",
        "means=[]\n",
        "stds=[]\n",
        "for i in np.unique(train_dataset[:]['dataset']):\n",
        "    ind=train_dataset[:]['dataset']==i\n",
        "    means.append(torch.cat((train_dataset[:]['src'][ind, 1:, 2:4], train_dataset[:]['trg'][ind, :, 2:4]), 1).mean((0, 1)))\n",
        "    stds.append(\n",
        "        torch.cat((train_dataset[:]['src'][ind, 1:, 2:4], train_dataset[:]['trg'][ind, :, 2:4]), 1).std((0, 1)))\n",
        "mean=torch.stack(means).mean(0)\n",
        "std=torch.stack(stds).mean(0)\n",
        "\n",
        "train_loss, learning_rates = learning_rate_finder(tf_model, optimizer, train_loader, iterations, device, mean, std)\n",
        "eta_star = learning_rates[np.argmin(np.array(train_loss))]\n",
        "eta_max = eta_star/10\n",
        "print(\"Value of eta max is: {:.4f}\".format(eta_max))\n",
        "\n",
        "# plotting results\n",
        "plt.figure()\n",
        "plt.plot(learning_rates, train_loss)\n",
        "plt.xlabel(\"Learning rates\")\n",
        "plt.ylabel(\"Training loss\")\n",
        "plt.xscale('log')\n",
        "plt.title(\"Learning Rate Finder Algorithm\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 415
        },
        "id": "J1viVzbAvkqC",
        "outputId": "dcfd50ba-53a8-4b4a-929a-43127187a040"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  0%|          | 0/100 [00:33<?, ?it/s]\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-28-467bf52c63a9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     66\u001b[0m         \u001b[0;31m# forward pass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 68\u001b[0;31m         \u001b[0mpredictions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menc_input\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdec_input\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdec_source_mask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdec_target_mask\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     69\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     70\u001b[0m         \u001b[0;31m# calculating loss using pairwise distance of all predictions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-22-a896569b75d6>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, enc_input, dec_input, dec_source_mask, dec_target_mask)\u001b[0m\n\u001b[1;32m    460\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    461\u001b[0m         \u001b[0mdec_embed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecoder_embeddings\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdec_input\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 462\u001b[0;31m         \u001b[0mdecoder_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecoder_block\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdec_embed\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mencoder_output\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdec_source_mask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdec_target_mask\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    463\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    464\u001b[0m         \u001b[0mmodel_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutput_gen\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdecoder_output\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-22-a896569b75d6>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, enc_output, source_mask, target_mask)\u001b[0m\n\u001b[1;32m    281\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    282\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mlayer\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdec_layers\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 283\u001b[0;31m             \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlayer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menc_output\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msource_mask\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_mask\u001b[0m\u001b[0;34m)\u001b[0m      \u001b[0;31m# Shape = (B, N, C)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    284\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    285\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnorm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m                                                    \u001b[0;31m# Shape = (B, N, C)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-22-a896569b75d6>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, enc_output, source_mask, target_mask)\u001b[0m\n\u001b[1;32m    235\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    236\u001b[0m         \u001b[0;31m# sublayer 2: Input -> LayerNorm -> EncoderDecoderAttention -> Dropout -> ResidualAdd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 237\u001b[0;31m         x = x + self.dropout(self.enc_dec_attn.forward(self.norm_enc_dec(x),\\\n\u001b[0m\u001b[1;32m    238\u001b[0m             self.norm_enc_dec(enc_output),self.norm_enc_dec(enc_output), source_mask))  # Shape = (B, N ,C)\n\u001b[1;32m    239\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "# training loop\n",
        "\n",
        "# creating model\n",
        "encoder_ip_size = 2\n",
        "decoder_ip_size = 3\n",
        "model_op_size = 3\n",
        "emb_size = 512\n",
        "num_heads = 8\n",
        "ff_hidden_size = 2048\n",
        "n = 6\n",
        "dropout=0.1\n",
        "\n",
        "tf_model = TFModel(encoder_ip_size, decoder_ip_size, model_op_size, emb_size, \\\n",
        "                num_heads, ff_hidden_size, n, dropout=0.1)\n",
        "tf_model = tf_model.to(device)\n",
        "\n",
        "# creating optimizer\n",
        "optimizer = torch.optim.SGD(tf_model.parameters(), lr=1e-4, momentum=0.9, weight_decay=1e-3, nesterov=True)\n",
        "# optimizer = torch.optim.Adam(tf_model.parameters(), lr=1e-4)\n",
        "\n",
        "# number of epochs \n",
        "epochs = 100\n",
        "\n",
        "# metric variables\n",
        "training_loss = []\n",
        "validation_loss = []\n",
        "val_mad = []\n",
        "val_fad = []\n",
        "\n",
        "# finding the total number of weight updates for the network\n",
        "T = epochs * len(train_loader)\n",
        "# initializing variable to track the number of weight updates\n",
        "weight_update = 0\n",
        "# initializing variable to store the changing learning rate\n",
        "learning_rate = []\n",
        "\n",
        "for epoch in tqdm(range(epochs)):\n",
        "    # TRAINING MODE\n",
        "    tf_model.train()\n",
        "    \n",
        "    # training batch variables\n",
        "    train_batch_loss = 0\n",
        "\n",
        "    for idx, data in enumerate(train_loader):\n",
        "        # changing the learning rate based on cosine scheduler\n",
        "        lr = cosine_scheduler(weight_update, eta_max, T)\n",
        "        for param in optimizer.param_groups:\n",
        "            learning_rate.append(lr)\n",
        "            param['lr'] = lr\n",
        "        weight_update += 1\n",
        "\n",
        "        # getting encoder input data\n",
        "        enc_input = (data['src'][:,1:,2:4].to(device)-mean.to(device))/std.to(device)\n",
        "\n",
        "        # getting decoder input data\n",
        "        target = (data['trg'][:,:-1,2:4].to(device)-mean.to(device))/std.to(device)\n",
        "        target_append = torch.zeros((target.shape[0],target.shape[1],1)).to(device)\n",
        "        target = torch.cat((target,target_append),-1)\n",
        "        start_of_seq = torch.Tensor([0, 0, 1]).unsqueeze(0).unsqueeze(1).repeat(target.shape[0],1,1).to(device)\n",
        "        dec_input = torch.cat((start_of_seq, target), 1)\n",
        "\n",
        "        # getting masks for decoder\n",
        "        dec_source_mask = torch.ones((enc_input.shape[0], 1,enc_input.shape[1])).to(device)\n",
        "        dec_target_mask = subsequent_mask(dec_input.shape[1]).repeat(dec_input.shape[0],1,1).to(device)\n",
        "\n",
        "        # forward pass \n",
        "        optimizer.zero_grad()\n",
        "        predictions = tf_model.forward(enc_input, dec_input, dec_source_mask, dec_target_mask)\n",
        "\n",
        "        # calculating loss using pairwise distance of all predictions\n",
        "        loss = F.pairwise_distance(predictions[:, :,0:2].contiguous().view(-1, 2),\n",
        "                                    ((data['trg'][:, :, 2:4].to(device)-mean.to(device))/std.to(device)).\\\n",
        "                                    contiguous().view(-1, 2).to(device)).mean() + \\\n",
        "                                    torch.mean(torch.abs(predictions[:,:,2]))\n",
        "        train_batch_loss += loss.item()\n",
        "        \n",
        "        # updating weights\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    training_loss.append(train_batch_loss/len(train_loader))\n",
        "    print(\"Epoch {}/{}....Training loss = {:.4f}\".format(epoch+1, epochs, training_loss[-1]))\n",
        "\n",
        "\n",
        "    # validation loop\n",
        "    if (epoch+1)%5 == 0:\n",
        "        with torch.no_grad():\n",
        "            # EVALUATION MODE\n",
        "            tf_model.eval()\n",
        "            \n",
        "            # validation variables\n",
        "            batch_val_loss=0\n",
        "            gt = []\n",
        "            pr = []\n",
        "\n",
        "            for id_b, data in enumerate(val_loader):\n",
        "                # storing groung truth \n",
        "                gt.append(data['trg'][:, :, 0:2])\n",
        "\n",
        "                # input to encoder input\n",
        "                val_input = (data['src'][:,1:,2:4].to(device)-mean.to(device))/std.to(device)\n",
        "\n",
        "                # input to decoder\n",
        "                start_of_seq = torch.Tensor([0, 0, 1]).unsqueeze(0).unsqueeze(1).repeat(val_input.shape[0], 1, 1).to(device)\n",
        "                dec_inp = start_of_seq\n",
        "                # decoder masks\n",
        "                dec_source_mask = torch.ones((val_input.shape[0], 1, val_input.shape[1])).to(device)\n",
        "                dec_target_mask = subsequent_mask(dec_inp.shape[1]).repeat(dec_inp.shape[0], 1, 1).to(device)\n",
        "\n",
        "                # prediction till horizon lenght\n",
        "                for i in range(horizon):\n",
        "                    # getting model prediction\n",
        "                    model_output = tf_model.forward(val_input, dec_inp, dec_source_mask, dec_target_mask)\n",
        "                    # appending the predicition to decoder input for next cycle\n",
        "                    dec_inp = torch.cat((dec_inp, model_output[:, -1:, :]), 1)\n",
        "\n",
        "                # calculating loss using pairwise distance of all predictions\n",
        "                val_loss = F.pairwise_distance(dec_inp[:,1:,0:2].contiguous().view(-1, 2),\n",
        "                                        ((data['trg'][:, :, 2:4].to(device)-mean.to(device))/std.to(device)).\\\n",
        "                                            contiguous().view(-1, 2).to(device)).mean() + \\\n",
        "                                            torch.mean(torch.abs(dec_inp[:,1:,2]))\n",
        "                batch_val_loss += val_loss.item()\n",
        "\n",
        "                # calculating the position for each time step of prediction based on velocity\n",
        "                preds_tr_b = (dec_inp[:, 1:, 0:2]*std.to(device) + mean.to(device)).cpu().numpy().cumsum(1) + \\\n",
        "                    data['src'][:,-1:,0:2].cpu().numpy()\n",
        "\n",
        "                pr.append(preds_tr_b)\n",
        "            validation_loss.append(batch_val_loss/len(val_loader))\n",
        "\n",
        "            # calculating mad and fad evaluation metrics\n",
        "            gt = np.concatenate(gt, 0)\n",
        "            pr = np.concatenate(pr, 0)\n",
        "            mad, fad, _ = distance_metrics(gt, pr)\n",
        "            val_mad.append(mad)\n",
        "            val_fad.append(fad)\n",
        "\n",
        "            print(\"Epoch {}/{}....Validation mad = {:.4f}, Validation fad = {:.4f}\".format(epoch+1, epochs, mad, fad))\n",
        "\n",
        "    if (epoch+1)%20 == 0:\n",
        "        # Saving model, loss and error log files\n",
        "        torch.save({\n",
        "            'model_state_dict': tf_model.state_dict(),\n",
        "            'optimizer_state_dict': optimizer.state_dict(),\n",
        "            'training_loss': training_loss,\n",
        "            'validation_loss': validation_loss,\n",
        "            'val_mad': val_mad,\n",
        "            'val_fad':val_fad,\n",
        "            'learning_rate':learning_rate\n",
        "            }, os.path.join(save_location, 'raw_cosine_sgd_epoch{}.pth'.format(epoch+1)))\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "yl1z_G7FFsYK"
      },
      "outputs": [],
      "source": [
        "# loading saved model file\n",
        "\n",
        "PATH = \"/content/drive/MyDrive/ESE_546_project/models\"\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "loaded_file = torch.load(os.path.join(PATH, 'raw_cosine_adam_epoch100.pth'), map_location=torch.device(device))\n",
        "\n",
        "# creating model and loading weights\n",
        "encoder_ip_size = 2\n",
        "decoder_ip_size = 3\n",
        "model_op_size = 3\n",
        "emb_size = 512\n",
        "num_heads = 8\n",
        "ff_hidden_size = 2048\n",
        "n = 6\n",
        "dropout=0.1\n",
        "\n",
        "model_loaded = TFModel(encoder_ip_size, decoder_ip_size, model_op_size, emb_size, \\\n",
        "                num_heads, ff_hidden_size, n, dropout=0.1)\n",
        "model_loaded = model_loaded.to(device)\n",
        "model_loaded.load_state_dict(loaded_file['model_state_dict'])\n",
        "\n",
        "# loading training metric variables\n",
        "training_loss = loaded_file['training_loss']\n",
        "validation_loss = loaded_file['validation_loss']\n",
        "val_mad = loaded_file['val_mad']\n",
        "val_fad = loaded_file['val_fad']\n",
        "learning_rate = loaded_file['learning_rate']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "tDmeq7rFGVoY",
        "outputId": "eaa01e65-dc67-480b-955c-af8b82a1cd62"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Validation FAD VS Number of Epochs')"
            ]
          },
          "metadata": {},
          "execution_count": 31
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEWCAYAAACNJFuYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3xV9f348dc7O0AGkIS9QaaywnAhOHDPOiu4xap1tFq1y2rb76+t1lZrXTgKjuKira2tGqQgKjPIkIQNsjNYCYTsvH9/nBN6DSHJhdycO97Px+M8cu85957zPjf33vc9n885n7eoKsYYY4yvKK8DMMYYE3wsORhjjDmCJQdjjDFHsORgjDHmCJYcjDHGHMGSgzHGmCNYcjCIyOkistbrOMz/iMh4Ednu4fYvF5FtInJQRIZ7FYdPPD1FREUkxutYIoUlB4+JyDcicraXMajq56ra38sY6jqeLwMRSRCR/SJyZj3L/igi77u3TxOR+SJSJCJ7ReRLERl1lHU+5sZztc+8GHdeT39jDAG/B76vqm1UdVndhe5+l7jJo3Z6yIM4TYBYcogAIhLtdQx1BTImVS0D3gFuqGeb1wHTRSQZ+BB4FmgHdAEeB8obWPVe4PFgfD0bcoy/tnsAOY08ZqibPGqnJ45hOyZIWXIIUiISJSKPiMhGEdkjIu+KSDuf5e+JSJ77q3eeiAz2WTZNRF4Qkf+ISAkwwT1CeVBEVrrPeUdEEtzHf6sJo6HHussfEpFdIrJTRG5zf0X2bWR/6ovpQhFZJiLFbhPGYz5Pmef+3e/+Kj3ZXc8tIrJaRPaJyCci0uMom5wOfEdEWvnMOxfnPf8RcAKAqs5Q1WpVLVXVLFVd2cBufAxUAJOOso9zReQ2n/s3icgXPvdVRO4SkfUickBEfiUifdyjl2L3fxxXZ50/EZHd7v/kep/58SLyexHZKiL5IvKiiCS6y8aLyHYReVhE8oC/1BNrlIj8TES2iEiBiLwuIinueg8C0cAKEdnYwOtRL/co6333fXNARL4SkaE+ywe6r9V+EckRkUt8liWKyFNuXEUi8kXtfrmud/d5t4j81Od5o0Uk230d80XkD/7GbepQVZs8nIBvgLPrmX8fsBDoCsQDLwEzfJbfAiS5y54GlvssmwYUAafifBkmuNtZDHTG+aW8Gvie+/jxwPY6MR3tsecBecBgoBXwJqBA30b2s76YxgMnuvdPAvKBy9zH93TXG+OzjkuBDcBAIAb4GTC/gW2uAyb53J8BPO3eTgb24CSR84G2jcT/mLuvlwCbgFg3BgV6uo+ZC9zm85ybgC987ivwgbvtwThHKbOB3kAKkAvc6PM/qQL+4P6PzwBKgP7u8j8C/3T/P0nAv4Df1Hnu79znJtazP7e4r2VvoA3wN+CNOrEe9X/a0HL3taoErnRfpweBze7tWHe7PwHigDOBAz779Zz7OnbBSVCnuPtQ+354GUgEhrqv30D3eQuAye7tNsBYrz/boT55HsBR3lyvAQXAqmZaXzWw3J3+6fX+1YntG+pPDquBs3zud3I/cDH1PDbV/eCkuPenAa/Xsx3fL8ongBfd2+M5Mjkc7bGv1X4Juff7NvZFcrSY6nnM08Af3du1Xwa+yeEj4Faf+1HAIaDHUdb3MyDLvZ3sPna4z/KBblzbcb5M/wl0OMq6HgPedG8vAu7k2JLDqT73lwIP+9x/iv8lr/FuTK19lr8L/BwQnETRx2fZycBmn+dWAAkNvNazgbt87vf3fX819j91lxcD+32mc31eq4V1/k+7gNPdKQ+I8lk+w31OFFCK01xVd3u174euPvMWA9e6t+fhNAumteTnN5ynYG1WmobzC7W5lKrqMHe6pPGHB4UewN/dQ+/9OMmiGuggItEi8lu3yakY58scIM3n+dvqWWeez+1DOL+wjuZoj+1cZ931bedovvVYERkjInNEpFBEioDv8e19qKsH8IzPa7IX54uyy1Ee/wZO81VnnF+xG9Wnc1VVV6vqTaraFRji7tvTTdiPnwE/xTn68Ve+z+3Seu77/k/2qWqJz/0tbozpOEdtS31ei4/d+bUK1el7OZrO7vp81x0DdGjqjgAjVDXVZ/rEZ9nh/7Wq1uAk4M7utM2d57vtLjj/+wSgoaaso70vb8VpKlwjIktE5CI/9sPUIyiTg6rOw/ngH+a2zX4sIktF5HMRGeBReC1lG3B+nQ9fgqruAL6L08RyNk5zRE/3OeLz/EANt7sLp6mrVjc/nls3pr/i/FrvpqopwIv8bx/qi38bcEed1yRRVefXuzHVLcDnOH0Ek3GakOoPTHUNzo+SIY3uhOosnKaRu+osKsH50q7VsbF1NaKtiLT2ud8d2Ansxkkkg31ehxRV9U0sjf3/d+IkW991V/HtZHU8Dr8vRCQK5z2z0526ufN8t70DZ7/KgD7+bkxV16vqdUAGTnPa+3VeO+OnoEwORzEVuEdVR+K0YT7vx3MT3M6qhSJyWWDCOy6x4px+WTvF4HxR/l9th6uIpIvIpe7jk3DaW/fgfBn9vxaM9V3gZrdTsRVOM8exSgL2qmqZiIzGSXq1CoEanDbxWi8CPxa3893tQL2qkW1MB76P09fxVu1MERkgIg+ISFf3fjecM5kWNjH2nwJ1T91cDlwhIq3E6aC/tYnrasjjIhInIqcDFwHvub+6Xwb+KCIZbvxdRORcP9Y7A/iBiPQSkTY476F3VLWqGWIGGCkiV7jv5ftx3q8LcZrkDgEPiUisiIwHLgbedvfrNeAPItLZPUI+WUTiG9uYiEwSkXR3Hfvd2TUNPcc0LCSSg/vmPQV4T0SW43TOdnKXXSEiq+qZfA9xe6hqJs6Xz9Mi4vcvkwD7D84vwdrpMeAZnF/VWSJyAOeDNcZ9/Os4h+I7cDoxm/qFdtxU9SPgT8AcnF/Ptdtu6BTQo7kL+KW7f4/iJJ7a7RwC/g/40m06Gauqf8f5Vfi225y2CqczuSEzcTptZ6vqLp/5B3Bez0XinD210F3fA00JXFW/xGnz9vVHnLb+fJyk9Fbd5/kpD9iH82v7LZyTAta4yx7Gff3d1+JTnH6DpnoNp9ltHk5ncRlwj5/xrZBvX+fg2yT3AXCNG/9k4ApVrVTVCpxkcD7OkcLzwA0++/Ug8DWwBKf14Hc07XvqPCDHPdPqGZy+iFI/98f4ENXgLPYjzoVFH6rqEHHOSV+rqp2aYb3T3PW+f7zrMs5piThfqvHN+KvThDBxTknuq6r1nvJrQkNIHDmoajGwubYJQRxDG3ka7mPb1h6WikgaTvNCbsCCjQDiDK0QLyJtcX7Z/csSgzHhJSiTg4jMwDlvub84F/PcClwP3CoiK3Cu3Ly0oXX4GAhku8+bA/xWVS05HJ87cE413ohzBtWdAOJc0HSwnun6hlZmjAk+QdusZIwxxjtBeeRgjDHGW0E1/G1aWpr27NnT6zCMMSakLF26dLeqpjf+yKYLquTQs2dPsrOzvQ7DGGNCiohsafxR/rFmJWOMMUew5GCMMeYIlhyMMcYcwZKDMcaYI1hyMMYYcwRLDsYYY45gycEYY8wRLDmEqOoa5d0l2yitqPY6FGNMGLLkEKJmLN7KQzNX8taiZr/2xRhjLDmEqo9XOaV0E+OiPY7EGBOOgmr4DNM01TXK/I27AXji47VMnbeJmCghNjqKuJgoEmOjSUmMJTkx1vmbEEu71rF0SE6gU0oiHVLiSWsdT1SUNLIlY0yksuQQgpZt3UeNQv8OSZzUNYXK6hoqq5WK6hoqq2s4VF7N1r2HKCqtpLi0kpJ6+iVio4UOyQn0Smt9eOqd3obeaa3pkppoicOYCGfJIQTNys0nNlp4/86TSUqIbfTxldU17CupIK+4jF1FZeS7f3fuL+Wb3SX8/asdHCj/XyG3NvExDOqUzKDOyQzunMzgzin069CG2GhrhTQmUlhyCDGqyic5eZzcJ61JiQEgNjqKjOQEMpITOKlr/evcfbCCzbtL2Fh4kNydxeTsLOKdJdsorXSOOhJjoxnePZXMnu0Y1bMtw7u3pU28vX2MCVf26Q4xGwoO8s2eQ9x2eu9mW6eIkJ4UT3pSPKN7tTs8v7pG2by7hJydRSzbup/sLXv583/XU6MQJTC4cwqn9UtjXL90RvZoS1yMHVkYEy4sOYSYrNx8AM4Z1CHg24qOEvpmtKFvRhsuHdYFgIPlVSzbuo8l3+xj4cY9vDxvEy/M3UjruGhO7tOecSekc9bADnRJTQx4fMaYwAmqGtKZmZlqxX4adumfv0BE+Mfdp3odCgAHyiqZv3EP89YVMm99Idv2lgJwUtcUzh3ckfOGdKRPehuPozQmvInIUlXNbM512pFDCNlVVMqK7UU8dF5/r0M5LCkhlnMHd+TcwR1RdZqhPsnJ5+OcPJ78ZC1PfrKWfhltOP/ETlw+vAu90lp7HbIxpgkCmhxEpD/wjs+s3sCjqvp0ILcbrj51m5QmDurocST1ExF6p7fhzvFtuHN8H3buLyUrJ4+PVuXx7H/X86fZ6xnWLZXLh3fh4qGdadc6zuuQjTFH0WLNSiISDewAxqhqvWM+WLNSwya/uogd+0v57wPjvQ7Fb3lFZfxzxQ7+9tUO1uQdICZKGN8/nWtGdWdC/3Ri7DRZY45ZqDcrnQVsPFpiMA0rKq1kwcY9zXqWUkvqmJLAlHF9mDKuD6t3FfOPZTv4+7IdfLo6m04pCVwzqhvXjupOx5QEr0M1xtCyyeFaYEbdmSIyBZgC0L179xYMJ7TMXVtAVY22yFlKgTawUzIDOyXzo3P7M3tNAW8t2srTn67n2f9u4MwBGUwa24Nx/dIQsau0jfFKizQriUgcsBMYrKr5R3ucNSsd3d1//YpFm/ay+CdnheXQFlv3HGLGkq28u2Qbe0oqOKFDG247rTeXDOtMQqwNLmhMQwLRrNRSDb3nA181lBjM0ZVXVTN3TQHnDOoQlokBoHv7Vjx83gAW/PgsnrpqKFEiPDRzJaf97r/8afZ69pZUeB2iMRGlpZqVrqOeJiXTNPM37qGkopqJg0O/SakxcTFRfGdkV64Y0YUvN+zhlS828YdZ63huzgauHdWNO87oQ2e7wM6YgAt4chCR1sA5wB2B3la4ysrJp3VcNKf0ae91KC1GRDitXxqn9UtjXf4BXp63ibcWbeWvi7dyVWY37jyjD93atfI6TGPCVsCblVS1RFXbq2pRoLcVjmpqlFm5+YwfkEF8TGS2vZ/QIYknrxrKnAfHc3VmN97P3s6E38/lofdXsGVPidfhGROW7OTyILds2352HyxnYhicpXS8urVrxf9dfiKfPTSeSWN78MHynZz51Gc8MnMleUVlXodnTFix5BDksnLziI0WJgzI8DqUoNEpJZHHLhnM5w9NYPLYHsz8ajtnPDmH33y0mv2HrOPamOZgySHIzcrJZ2zv9iQ3sXZDJMlITuCxSwbz3wfGc+GJnZg6bxPjnpjD83M3UFpP9TtjTNNZcghiGwoOsml3iTUpNaJbu1b84Zph/Ofe0xnVsx1PfLyW8b+fw8yl26mpCZ5Rh40JJZYcglhWbh4AZ1tyaJKBnZJ59aZRvHvHyXRMSeSB91Zw+QvzWbpln9ehGRNyLDkEsaycfIZ2TaFTip3X74/Rvdrx9ztP4amrhrJrfynfeWE+97+9jF1FpV6HZkzIsOQQpPKLy1i+bT8TBwfn8NzBLipK+M7Irsx5cDzfn9CX/6zK48zff8afZq+nrNL6I4xpjCWHIDXrcO0Ga1I6Hq3jY3jw3P7M/uEZTBiQzh9mreOCZz7nyw27vQ7NmKBmySFIZeXm0yutNX0zrMRmc+jWrhXPXz+S128ZTbUq17+yiPvfXkbhgXKvQzMmKFlyCELFZZUs2LibiYM62LDVzWzcCel8cv847jmzL//+ehdnPTWXtxZtsbOajKnDkkMQmru2kMpqjYiB9ryQEBvNAxP789F94xjUOZmf/n0VV744nw0FB7wOzZigYckhCGXl5JHWJp5h3dp6HUpY65vRhhm3j+Wpq4ayaXcJF/zpC56fu4Gq6hqvQzPGc5Ycgkx5VTVz1xZy9sAMosO0dkMwEXHOapr1gzM4a0AGT3y8litemM/aPDuKMJHNkkOQWbhpLwfLq6xJqYWlJ8XzwqSRPPfdEWzfV8pFz37Os7PXU2lHESZCWXIIMlk5ebSKi+aUPmlehxKRLjypE7N+MI5zB3fkqVnruOy5L1mXb0cRJvJYcggih2s39E+3uskeat8mnj9/dwQvThpJfnEZFz37BX/5crOd0WQiiiWHILJi+34KDpQzcZBdFR0MzhvSkY/uG8dpfdN4/F+53DRtCfnFVjfCRAZLDkEkKzefmChhQn+r3RAs0pPiefXGTH592RAWb97DeU/P4+NVeV6HZUzABTw5iEiqiLwvImtEZLWInBzobYaqrJw8xvZuT0orq90QTESESWN78O97T6dr21Z8782lPPT+Cg6WV3kdmjEB0xJHDs8AH6vqAGAosLoFthlyNhQcZGNhiZ2lFMT6pLdh5p2ncPeEPry3dDuXPPsFuTuLvQ7LmIAIaHIQkRRgHPAqgKpWqOr+QG4zVNUOtHf2QEsOwSwuJoofnTuAGbePpaSiisue/5I3F25B1TqrTXgJ9JFDL6AQ+IuILBORV0Skte8DRGSKiGSLSHZhYWGAwwles3LzOLFLCp1TrXZDKBjbuz3/ufd0xvZuz8/+sYrvz1jGgbJKr8MyptkEOjnEACOAF1R1OFACPOL7AFWdqqqZqpqZnp4e4HCCU0FxGcu27bfhuUNM+zbxTLtpFA+d15+PV+Vx0bNfsGpHkddhGdMsAp0ctgPbVXWRe/99nGRhfHy6ugBVrLBPCIqKEu4a35e3p4ylvLKGK56fz+sLvrFmJhPyApocVDUP2CYi/d1ZZwG5gdxmKMrKzaNH+1ac0MFqN4SqUT3b8Z/7TufUvu159IMcfvDOckorrOKcCV0tcbbSPcBbIrISGAb8vxbYZsg4UFbJ/A17rHZDGGjXOo5XbxzFA+ecwAcrdnLFC/PZuueQ12EZc0wCnhxUdbnbp3CSql6mqvsCvc1Q8tm6Qiqqa6xJKUxERQn3nNWP124axc79pVz85y+Yu7bA67CM8ZtdIe2xrJx82reOY0R3q90QTib0z+Bf3z+NzqmJ3DxtCc/OXm9jM5mQYsnBQxVVNcxZU8DZAztY7YYw1L19K/525ylcOrQzT81ax5Q3llJsp7uaEGHJwUMLN+3hgNVuCGuJcdH88ZphPHbxIOauLeDy577km90lXodlTKMsOXhoVm4+ibHRnNrXajeEMxHhplN78dZtY9hbUsGlz33J/A27vQ7LmAZZcvBIbe2GM06w2g2RYkzv9nxw92lkJMUz+bXFvLFwi9chGXNUlhw88vWOIvKKy6xJKcJ0b9+Kv911CuP6pfHzf6zi0Q9WUWWlSE0QsuTgkazcPKKjhDMHWO2GSJOUEMsrN47i9tN78fqCLdz0lyUUHbKOahNcLDl4JCsnnzG92pHaKs7rUIwHoqOEn144iCeuPIlFm/dw2fNfsqnwoNdhGXOYJQcPbCo8yPqCgzbQnuHqzG789faxFJVWcsUL81nyzV6vQzIGsOTgidraDefYVdEGZ1ymv991Cm1bxXH9K4v414qdXodkjCUHL2Tl5jOkSzJdrHaDcfVo35q/3XkKJ3VJ4Z4Zy3jxs402sqvxlCWHFlZ4oJyvtu5j4iA7ajDf1rZ1HG/eNoYLT+rEbz9aw8/+YWcyGe/EeB1ApJm9Oh9VOMf6G0w9EmKjefba4XRtm8hLn21iV1EZz143nNbx9lE1LcuOHFpYVm4+3dolMqBjktehmCAVFSX8+PyB/PqyIcxdW8A1UxdQUFzmdVgmwlhyaEEHy6v4YsNuJg7qaLUbTKMmje3BKzdmsqmwhO+8ON/GZDItypJDC5q3rpCKqho7hdU02ZkDOvDX28dysKyKK1+cbzWqTYux5NCCsnLyaNc6jpE9rHaDabph3VJ573unEB8TzbVTFzJ/ow3aZwIv4MlBRL4Rka9FZLmIZAd6e8GqsrqG2WsKOGtABjHRlpONf/pmtOH9O0+mc2oCN722hI9X7fI6JBPmWupbaoKqDlPVzBbaXtBZtGkvB8qqrByoOWadUhJ5946TObFrCne99RV/XbTV65BMGLOfsC0kKzePxNhoTu9ntRvMsUttFcebt45hfP8MfvL3r3l29nq7WM4EREskBwWyRGSpiEypu1BEpohItohkFxYWtkA4LU/Vqd0w7oQ0q91gjltiXDQvTR7JFSO68NSsdTz+r1yrT22aXUtcWXOaqu4QkQxgloisUdV5tQtVdSowFSAzMzMs3+GrdhSzq6iMByb29zoUEyZio6P4/ZVDadcqjle+2ExJeRW//c5JVovcNJuAJwdV3eH+LRCRvwOjgXkNPyu8ZOXmESVwltVuMM0oKkr46YUDaZMQw9Ofrqe0spo/XjOMWDvhwTSDJr+LRKSDiLwqIh+59weJyK2NPKe1iCTV3gYmAquOJ+BQlJWTz+he7Wjb2mo3mOYlItx/9gn85IIBfLhyF3e+uZSyymqvwzJhwJ+fGNOAT4DO7v11wP2NPKcD8IWIrAAWA/9W1Y/9DTKUfbO7hLX5B2ygPRNQU8b14VeXDeHT1QXcOn0JhyqqvA7JhDh/kkOaqr4L1ACoahXQ4E8UVd2kqkPdabCq/t9xxBqSDtdusKuiTYBNHtuDp64ayoKNe7jh1cUUl1npUXPs/EkOJSLSHufsI0RkLGDX8jciKzePQZ2S6dauldehmAjwnZFd+fN3R7Bi+36++/JC9pZUeB2SCVH+JIcfAv8E+ojIl8DrwL0BiSpM7D5YTvaWfUwcbEcNpuVccGInpk7OZF3+Qa6duoCCAzaiq/GfP8khBzgDOAW4AxgMrAlEUOGitnaD9TeYljZhQAbTbh7F9n2lXDd1oQ35bfzmT3JYoKpVqpqjqqtUtRJYEKjAwsGs3Hy6tk1kYCer3WBa3il90ph282h2FZVx7dSF5FuCMH5oNDmISEcRGQkkishwERnhTuMBa0g/ipLyKuat3805gzpY7QbjmdG92jH9ltHkFzsJIq/IEoRpmqYcOZwL/B7oCvwBeMqdfgj8JHChhbbP19fWbrAmJeOtUT2dBFFQXMa1Uxewq6jU65BMCGg0OajqdFWdANykqhN8pktU9W8tEGNIysrJJ7VVLKN6Wu0G473Mnu14/dbR7D5YwbVTF7JzvyUI07Am9zmo6kwRuVBEHhKRR2unQAYXqv5Xu6GD1W4wQWNkDydB7HUTxA5LEKYB/gyf8SJwDXAPIMBVQI8AxRXSlmzeS1FppZ3CaoLOiO5tef3W0ewrqeDaqQvYvu+Q1yGZIOXPz9pTVPUGYJ+qPg6cDJwQmLBCW1ZuPgmxUYzrl+51KMYcYXj3trxx2xj2H6q0IwhzVP4kh9rTHA6JSGegEujU/CGFNlUlKyeP0/ulkxhntRtMcBrWLZU3bx1D0aFKrn/ZTnM1R/InOfxLRFKBJ4GvgG+AvwYiqFCWs7OYnUVlTLSxlEyQG9otlWm3jKbwQDnffXkhhQfKvQ7JBJEmJQcRiQJmq+p+VZ2J09cwQFWtQ7qOrNx8p3bDQEsOJviN7NGW124axY79pUx6ZZGNxWQOa1JyUNUa4Dmf++WqaoPu1SMrJ4/Mnu1oZ7UbTIgY07s9r9wwis17Spj86iKKSm00V+Nfs9JsEfmO2OW+R7V1zyHW5B2wJiUTck7rl8ZLk0eyLv8AN762mAM23HfE8yc53AG8B5SLSLGIHBCR4gDFFZKycvMAG2jPhKYJ/TN47rsjWLWjiFumWcGgSOfPRXBJqhqlqnGqmuzeT65dLiKDAxNi6MjKzWdAxyS6t7chp0xomji4I89cO5ylW/Zx2/RsKzkawZrz8t03jrZARKJFZJmIfNiM2wsqew6Wk/3NXiYOtqMGE9ouPKkTT109lAWb9jDljaWUV1mCiETNmRwa6ou4D1jdjNsKOrPXFFCjWH+DCQuXD+/K7644iXnrCrl3xjKqqmu8Dsm0sOZMDlrfTBHpClwIvNKM2wo6WTn5dElNZHDn5MYfbEwIuHpUN35x8SA+ycnn4ZlfU1NT70fchKmYFtjG08BDQNhWvDlUUcXn6wu5bnR3q91gwsrNp/aiuLSKP366jqSEGH5x8SB7j0eI5kwOR1w9IyIXAQWqutQtDnQEEZkCTAHo3r17M4bTcj5fv5vyqhobaM+EpXvP6ktRaSWvfbmZlMRYfnCODakWCZqcHERkRD2zi4AtbvnQsfUsPxW4REQuABKAZBF5U1Un1T5AVacCUwEyMzND8rg1KyeflMRYRvds53UoxjQ7EeFnFw7kQFklz8xeT3JiLLee1svrsEyA+XPk8DwwAliJ0/k8BMgBUkTkTlXNqvsEVf0x8GMA98jhQd/EEA6qqmuYvSafswZkWO0GE7aiooTfXHEiB8ur+NWHuSQlxHB1ZjevwzIB5M+32U5guKpmqupIYDiwCTgHeCIQwYWCJd/sY/8hq91gwl9MdBRPXzuM0/ul8cjMlXy8apfXIZkA8ic5nKCqObV3VDUXZ/C9TU15sqrOVdWL/A0w2GXl5hEfE8W4E6x2gwl/8THRvDR5JMO7t+XeGcv5fH2h1yGZAPEnOeSIyAsicoY7PQ/kikg8Tm2HiOPUbsjn9H5ptIpriRO/jPFeq7gYXrtxFL3TWzPl9aUs3bLP65BMAPiTHG4CNgD3u9Mmd14lMKG5AwsFubuK2bG/1MZSMhEnpVUsb9w6hg7J8dz8l8WszTvgdUimmfkztlKpqj6lqpe70+9V9ZCq1qjqwUAGGayycmprN2R4HYoxLS49KZ43bxtDYlw0N7622MqNhpkmJwcROVVEZonIOhHZVDsFMrhgl5WbT2aPdrRvE+91KMZ4omvbVky/ZTQlFVXc8Ooi9lmxoLDhT7PSq8AfgNOAUT5TRNq29xCrdxXbWUom4g3omMwrN2SybV8pt0y3ob7DhT/JoUhVP1LVAlXdUzsFLLIgNys3H4BzbKA9YxjTuz1/unY4K7bt5/t/XUalDdQX8vxJDnNE5EkROVlERtROAYssyGXl5tG/Q+sigqAAABkzSURBVBI92rf2OhRjgsJ5Qzryq8uG8N81BTwy82tUQ3LAA+Py5/zLMe7fTJ95CpzZfOGEhn0lFSzevJe7J/T1OhRjgsr1Y3pQeKCcpz9dT3pSPI+cP8DrkMwxanJyUNWIPF21Pv+r3WCnsBpT131n9aPwQDkvfraR9KR4G4cpRDWaHERkkqq+KSI/rG+5qv6h+cMKblk5eXRKSWBIF6vdYExdIsIvLx3CnoMV/OrDXNLaxHHpsC5eh2X81JQ+h9pG9aSjTBGltKKaeesLmTiog41rb8xRREcJT187jNG92vHgeyuYt86G2Qg1jR45qOpL7t/HAx9O8Pt8fSFllTVWK9qYRiTERvPyDZlc89ICvvfmUt6942SGdEnxOizTRP5cBJcuIj8Rkaki8lrtFMjgglFWbj7JCTGM7mW1G4xpTEpiLNNvGU3bVnHcPG0J2/cd8jok00T+nMr6AZACfAr822eKGFXVNcxenc9ZAzsQa7UbjGmSDskJ/OXmUZRVVnPTX5ZQdCgix+kMOf58w7VS1YdV9V1VnVk7BSyyILR0yz72Haq0C9+M8dMJHZJ4afJItuwpYcob2ZRXVXsdkmmEP8nhQ7fcZ8TKys0nzmo3GHNMTumTxu+vGsqizXt58L2V1NTYRXLBzJ+L4O4DfiIi5TjDdAugqhoR53OqKlm5eZzWN4028Va7wZhjcemwLuzYX8oTH6+lS2qiXSQXxJr0LSciUcB5qvplgOMJWmvyDrBtbyl3j7eroo05Hnee0Yft+0p58bONdGmbyOSxPbwOydSjSc1KqloD/NnflYtIgogsFpEVIpIjIiF7OmxWTj4icNZA628w5niICL+8ZDBnDsjgFx+s4lN3EEsTXPzpc5gtIt8R/678KgfOVNWhwDDgPBEZ61eEQSIrN4+R3duSnmS1G4w5XjHRUTx73XAGd07hnhnLWLFtv9chmTr8SQ53AO8B5SJSLCIHRKS4oSeoo7ZKXKw7hVwv1PZ9h8jZabUbjGlOreNjePWmTNq3iePW6UvYuseugQgm/pQJTVLVKFWNU9Vk936jndEiEi0iy4ECYJaqLqqzfIqIZItIdmFhcF5i/+nh2g12VbQxzSkjKYFpN4+mslq56S+LrZJcEPHrSi4RaSsio0VkXO3U2HNUtVpVhwFdgdEiMqTO8qmqmqmqmenpwXmKaFZuPid0aEOvNKvdYExz65vRhpdvyGT7/lJufz2bskq7BiIY+DN8xm3APOAT4HH372NNfb6q7gfmAOf5F6K39h+qYNHmvXbhmzEBNLpXO566aijZW/bx8MyVVigoCPhz5HAfTs3oLW5th+FAg71I7nhMqe7tROAcYM0xxuqJ/64poLpGrXaDMQF28dDOPDjxBD5YvpNnZq/3OpyI58/VXGWqWiYiiEi8qq4Rkf6NPKcTMF1EonES0buq+uExR+uBrJx8OiYncKKNJmlMwN09oS+bdx/i6U/X07N9ay4bbnUgvOJPctjuHgX8A5glIvuALQ09QVVX4hxhhKSyymo+W1fIlSO7EhVltRuMCTQR4TdXnMj2fYd46P2VdGmbyKieNgKyF/w5W+lyVd2vqo8BPwdeBS4LVGDB4Iv1uymtrLZTWI1pQXExUbw0eSRd2iYy5fVstuwp8TqkiOTv2UqnicjNqvoZsAAI62O+rNw8khJiGNOrvdehGBNRUlvF8dpNo1Dg5mk2zLcX/Dlb6RfAw8CP3VmxwJuBCCoYVNcos1cXcOaADOJirHaDMS2tV1prpk7OZNveQ3zvzaVUVNV4HVJE8edb73LgEqAEQFV3EsY1pL/auo89JRV2lpIxHhrdqx1PXHkSCzbt4Wf/+NpOcW1B/nRIV6iqiogCiEhYXxGWlZNHXHQUZ/QPzgvzjIkUlw/vyubdh/jT7PX0TGvNXTYycovw58jhXRF5CUgVkdtxyoW+HJiwvOXUbsjnlL7trXaDMUHgB2f345KhnXni47X85+tdXocTEZr8zaeqvxeRc4BioD/wqKrOClhkHlqXf5Atew5xx7g+XodijME5xfWJK09ix/5SfvDOcjqnJjKsW6rXYYU1v3paVXWWqv5IVR8M18QATpOSCJw9KMPrUIwxroTYaKZOHkmH5ARum57N9n02imsgNZocaofmrmdqdMjuUJWVm8/wbqlkJCV4HYoxxkf7NvG8dtMoKqqquW16NiXlVV6HFLYaTQ61Q3PXMzVpyO5Qs3N/KV/vKGLiYDtLyZhg1DejDc9dP4L1BQe5/53l1NTYGUyBYCfw1zHLrd0w0UZhNSZond4vnUcvGsSs3HyezFrrdThhyU7FqSMrN4++GW3ond7G61CMMQ244eQerMs/wAtzN9Ivow1XjOjqdUhhxY4cfBQdqmTRpr121GBMCBARHrtkMKf0ac8jM79m6ZZ9XocUViw5+JiztoCqGrX+BmNCRGx0FM9fP4LOqQnc8UY2O/aXeh1S2LDk4CMrN4+MpHhOstoNxoSM1FZxvHLjKMqrauwMpmZkycFVVlnN3LWFnDOog9VuMCbE9M1ow3PfHcHavGJ+YGcwNQtLDq75G3dzqKLampSMCVHjTkjn5xcNIis3n6dm2RlMxyugyUFEuonIHBHJFZEcEbkvkNs7Hlk5+STFx3Byb6vdYEyouumUnlw3ujvPzdnIP5bt8DqckBboI4cq4AFVHQSMBe4WkUEB3qbfqmuUT1fnM95qNxgT0kSEX146mLG92/HQzJV8tdXOYDpWAf0mVNVdqvqVe/sAsJogrB63bOs+dh+ssFNYjQkDsdFRvHD9SDqlJDDl9aV2BtMxarGfySLSExgOLKozf4qIZItIdmFhYUuF8y1ZufnERgvjrXaDMWGhbes4Xr0xk/LKam6fns2hCjuDyV8tkhxEpA0wE7hfVb81WJ+qTlXVTFXNTE9v+S9nVSUrJ49T+qSRlBDb4ts3xgRG34wknv3ucNbYGUzHJODJQURicRLDW6r6t0Bvz18bCg7yzZ5DTBxsTUrGhJvx/TP46YWD+CQnn2dmr/c6nJAS0LGVRESAV4HVqvqHQG7rWGW5A+2dPdCSgzHh6JZTe7JmVzHPzF7PgI5JnH9iJ69DCgmBPnI4FZgMnCkiy93pggBv0y9ZOXkM65ZKh2Sr3WBMOBIRfn35EIZ3T+WB91aweldYlqFpdoE+W+kLVRVVPUlVh7nTfwK5TX/sKiplxfYia1IyJszFx0Tz0qSRJCXEcPvr2ewtqfA6pKAX0Sf1f3q4doNdFW1MuMtITmDq5EwKDpRz91tfUVld43VIQS2ik0NWbj6901vTN8NqNxgTCYZ2S+W3V5zIgk17+PWHuV6HE9QiNjkUlVayYOMeO2owJsJcMaIrt5/ei+kLtvD24q1ehxO0IjY5zD1cu8H6G4yJNA+fN4DT+6Xx8w9Wkf3NXq/DCUoRmxyycvNJT4pnWNdUr0MxxrSwmOgo/nzdCLqkJvK9N79ipw2xcYSITA7lVdXMXVNgtRuMiWAprWJ55cZMyiqrueONpZRVVnsdUlCJyOQwf+MeSiqqOccG2jMmovXNSOLpa4axamcRD89ciaoNsVErIpNDVk4+reOiOaWP1W4wJtKdPagDD07szwfLd/LSvE1ehxM0Ii451NQos3Kd2g3xMdFeh2OMCQJ3je/DRSd14ncfr2HOmgKvwwkKEZcclm3bz+6D5Va7wRhzmIjwxJUnMbBjMve+vYyNhQe9DslzEZccsnLziI0WJgzI8DoUY0wQaRUXw8s3ZhIXHcXt07MpKq30OiRPRVRycGo35DO2d3uSrXaDMaaOLqmJvDBpJFv3HuK+t5dRHcE1ICIqOWwsPMjm3SVMHGxXRRtj6je6Vzsev3Qwc9cW8sQna7wOxzMBrecQbGprN5xjtRuMMQ24fkwPcncW89JnmxjSOYWLh3b2OqQWF1FHDlk5+QztlkrHFKvdYIxp2C8uHkxmj7Y89P5KcndGXg2IiEkO+cVlLN+2385SMsY0SVxMFM9PGkFyYgx3vJnNvgirARExyWHW4doNlhyMMU2TkZTAi5NGkl9Uzr1vL6MqgmpABDQ5iMhrIlIgIqsCuZ2myMrNp1ea1W4wxvhnePe2/OqywXy+fjdPfrLW63BaTKCPHKYB5wV4G40qLqtkwcbdTBzUAREbaM8Y459rRnVn0tjuvDRvE/9csdPrcFpEoGtIzwM8Hyx97tpCKqutdoMx5tg9elFtB/WKiOigjog+h6ycPNLaxDOsW1uvQzHGhKjaDuqUxFimvBH+HdSeJwcRmSIi2SKSXVhY2OzrL6+qZu7aQs4ZlEG01W4wxhyH2g7qguJy7pkR3h3UnicHVZ2qqpmqmpment7s61+4aS8Hy6usVrQxplnUdlB/sWE3T4RxB3XYXyGdlZNH67hoTrbaDcaYZnLNqO58vaOIqfM2MbhzMpcO6+J1SM0u0KeyzgAWAP1FZLuI3BrI7dVVW7vhjP7pJMRa7QZjTPN59KLBjOrZlodnhucV1IE+W+k6Ve2kqrGq2lVVXw3k9upasX0/BQfKrUnJGNPs4mKieO76EaQmxoVlB7XnfQ6BlJWbT0yUMKG/1W4wxjS/jKQEXpg0Iiw7qMM7OeTkMbZ3e1JaWe0GY0xgDO/ell9fNiTsOqjDNjlsKDjIxsISu/DNGBNwV4/qxuSxPZg6bxMfLN/hdTjNImyTQ+1Ae2db7QZjTAv4+UWDDndQ5+ws8jqc4xbGySGPk7qm0Dk10etQjDERwLeD+o43loZ8B3VYJoeC4jKWWe0GY0wL8+2g/v6Mr0K6gzosk8OnqwtQxWpFG2NaXG0H9Zcb9vC7j0O3BnVYXiGdlZtHj/at6Ge1G4wxHrh6VDe+3lHEy59vZkiXlJC8gjrsjhwOlFUyf8Meq91gjPFUqHdQh11y+GxdIRXVNdakZIzxVFxMFM9fP9K5gvr1pewNsQ7qsEsOWTn5tG8dx4juVrvBGOOt9KR4Xpw8ksID5dwbYldQh1VyqKiqYc6aAs4e2MFqNxhjgsKwbqmHh/h+Mit0rqAOq+SwcNMeDpRX2VXRxpigcs2o7lw/pjsvfbaJD1eGRg3qsEoOs3LzaRUXzal907wOxRhjvuUXFw9mRPdUfvTeStbkBf8Q32GTHA7XbjjBajcYY4JPXEwUL0waSZuEGO54YylFhyq9DqlBYZMcvt5RRF5xmTUpGWOCVofkBF64fgQ79pVy3zvLqK5Rr0M6qrBJDlm5eURb7QZjTJDL7NmOX1wymLlrC3n603Veh3NU4ZMccvIZ06sdqa3ivA7FGGMaNGlMd67O7Mqz/93AJzl5XodTr4AnBxE5T0TWisgGEXkkENvILy5j8+4SG2jPGBMSRIRfXjqEoV1TeODdFWwoOOh1SEcIaHIQkWjgOeB8YBBwnYgMau7tdEhOYOnPz+E7I7s296qNMSYgEmKjeWHSSOJjopjyRjYHyoKrgzrQRw6jgQ2quklVK4C3gUsDsaGUxFiSEqwcqDEmdHROTeS560ewZc8hfvjuCmqCqIM60MmhC7DN5/52d95hIjJFRLJFJLuwsDDA4RhjTHAZ27s9P71gIP0y2hA8qSEIhuxW1anAVIDMzMxgem2MMaZF3HJaL69DOEKgjxx2AN187nd15xljjAligU4OS4B+ItJLROKAa4F/BnibxhhjjlNAm5VUtUpEvg98AkQDr6lqTiC3aYwx5vgFvM9BVf8D/CfQ2zHGGNN8wuYKaWOMMc3HkoMxxpgjWHIwxhhzBEsOxhhjjiCqwXPdmYgUAluOYxVpwO5mCifURPK+g+1/JO9/JO87OPvfWlXTm3OlQZUcjpeIZKtqptdxeCGS9x1s/yN5/yN53yFw+2/NSsYYY45gycEYY8wRwi05TPU6AA9F8r6D7X8k738k7zsEaP/Dqs/BGGNM8wi3IwdjjDHNwJKDMcaYI4RFchCR80RkrYhsEJFHvI7neIjIayJSICKrfOa1E5FZIrLe/dvWnS8i8id3v1eKyAif59zoPn69iNzoM3+kiHztPudPIiItu4dHJyLdRGSOiOSKSI6I3OfOj5T9TxCRxSKywt3/x935vURkkRvzO+7w94hIvHt/g7u8p8+6fuzOXysi5/rMD+rPiohEi8gyEfnQvR9J+/6N+95cLiLZ7jzv3vuqGtITzlDgG4HeQBywAhjkdVzHsT/jgBHAKp95TwCPuLcfAX7n3r4A+AgQYCywyJ3fDtjk/m3r3m7rLlvsPlbc557v9T777GcnYIR7OwlYBwyKoP0XoI17OxZY5Mb6LnCtO/9F4E739l3Ai+7ta4F33NuD3M9BPNDL/XxEh8JnBfgh8FfgQ/d+JO37N0BanXmevffD4chhNLBBVTepagXwNnCpxzEdM1WdB+ytM/tSYLp7ezpwmc/819WxEEgVkU7AucAsVd2rqvuAWcB57rJkVV2ozrvldZ91eU5Vd6nqV+7tA8BqnJrjkbL/qqoH3bux7qTAmcD77vy6+1/7urwPnOX+GrwUeFtVy1V1M7AB53MS1J8VEekKXAi84t4XImTfG+DZez8ckkMXYJvP/e3uvHDSQVV3ubfzgA7u7aPte0Pzt9czP+i4zQTDcX49R8z+u80qy4ECnA/2RmC/qla5D/GN+fB+usuLgPb4/7oEi6eBh4Aa9357ImffwfkhkCUiS0VkijvPs/d+wIv9mOalqioiYX3+sYi0AWYC96tqsW/TaLjvv6pWA8NEJBX4OzDA45BahIhcBBSo6lIRGe91PB45TVV3iEgGMEtE1vgubOn3fjgcOewAuvnc7+rOCyf57mEh7t8Cd/7R9r2h+V3rmR80RCQWJzG8pap/c2dHzP7XUtX9wBzgZJwmg9ofcr4xH95Pd3kKsAf/X5dgcCpwiYh8g9PkcybwDJGx7wCo6g73bwHOD4PRePne97oT5ngnnKOfTTidT7UdTYO9jus496kn3+6QfpJvd0o94d6+kG93Si3W/3VKbcbpkGrr3m6n9XdKXeD1/vrsp+C0hT5dZ36k7H86kOreTgQ+By4C3uPbnbJ3ubfv5tudsu+6twfz7U7ZTTgdsiHxWQHG878O6YjYd6A1kORzez5wnpfvfc9flGZ6YS/AObNlI/BTr+M5zn2ZAewCKnHaBW/FaUudDawHPvX5ZwvwnLvfXwOZPuu5BaczbgNws8/8TGCV+5w/414lHwwTcBpOu+tKYLk7XRBB+38SsMzd/1XAo+783u4He4P7ZRnvzk9w729wl/f2WddP3X1ci89ZKaHwWeHbySEi9t3dzxXulFMbn5fvfRs+wxhjzBHCoc/BGGNMM7PkYIwx5giWHIwxxhzBkoMxxpgjWHIwxhhzBEsOxhMioiLylM/9B0XksWZa9zQRubI51tXIdq4SkdUiMifQ26qz3ZtE5M8tuU0TeSw5GK+UA1eISJrXgfjyuRq3KW4FblfVCYGKxxivWHIwXqnCqX37g7oL6v7yF5GD7t/xIvKZiHwgIptE5Lcicr04NRC+FpE+Pqs5W0SyRWSdO25P7aB2T4rIEncM/Dt81vu5iPwTyK0nnuvc9a8Skd+58x7FuWjvVRF5sp7n/MhnO7V1GXqKyBoRecs94nhfRFq5y84Sp47B1+LU9Ih3548Skfni1HhYLCJJ7iY6i8jH7pj9T/js3zQ3zq9F5IjX1pimsoH3jJeeA1bWfrk10VBgIM6w5puAV1R1tDiFge4B7ncf1xNnbJo+wBwR6QvcABSp6ij3y/dLEclyHz8CGKLOMM+HiUhn4HfASGAfzqiZl6nqL0XkTOBBVc2u85yJQD93+wL8U0TGAVuB/sCtqvqliLwG3OU2EU0DzlLVdSLyOnCniDwPvANco6pLRCQZKHU3Mwxn1NpyYK2IPAtkAF1UdYgbR6ofr6sx32JHDsYzqlqMM5bSvX48bYk6dR/KcYYBqP1y/xonIdR6V1VrVHU9ThIZAEwEbnCHxF6EMzRBP/fxi+smBtcoYK6qFqozNPRbOAWZGjLRnZYBX7nbrt3ONlX90r39Js7RR39gs6quc+dPd7fRH9ilqkvAeb30f8NXz1bVIlUtwzna6eHuZ28ReVZEzgOKG4nTmKOyIwfjtadxvkD/4jOvCveHi4hE4QyUVqvc53aNz/0avv1+rjsujOL8ir9HVT/xXeAOEV1ybOHXS4DfqOpLdbbT8yhxHQvf16EaiFHVfSIyFKfgy/eAq3HG2THGb3bkYDylqntxSkHe6jP7G5xmHIBLcCqi+esqEYly+yF64wzC9glOc00sgIicICKtG1nPYuAMEUkTkWjgOuCzRp7zCXCLW5cCEenijtEP0F1ETnZvfxf4wo2tp9v0BTDZ3cZaoJOIjHLXk9RQh7nbuR+lqjOBn+E0lRlzTOzIwQSDp4Dv+9x/GfhARFYAH3Nsv+q34nyxJwPfU9UyEXkFp+npKxERoJBGSiWq6i5xitHPwTki+LeqftDIc7JEZCCwwNkMB4FJOL/w1wJ3u/0NucALbmw3A++5X/5LcIajrhCRa4BnRSQRp7/h7AY23QX4i3u0BfDjhuI0piE2KqsxLcRtVvqwtsPYmGBmzUrGGGOOYEcOxhhjjmBHDsYYY45gycEYY8wRLDkYY4w5giUHY4wxR7DkYIwx5gj/Hxc1v6n1BFnBAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "\n",
        "# plotting training loss\n",
        "plt.figure()\n",
        "plt.plot(training_loss)\n",
        "plt.xlabel(\"Number of epochs\")\n",
        "plt.ylabel(\"Training loss\")\n",
        "plt.title(\"Training loss VS Number of Epochs\")\n",
        "\n",
        "# plotting validation loss\n",
        "plt.figure()\n",
        "plt.plot(validation_loss)\n",
        "plt.xlabel(\"Number of epochs\")\n",
        "plt.ylabel(\"Validation loss\")\n",
        "plt.title(\"Validation loss VS Number of Epochs\")\n",
        "\n",
        "# plotting learning rate for model\n",
        "plt.figure()\n",
        "plt.plot(learning_rate)\n",
        "plt.xlabel(\"Number of epochs\")\n",
        "plt.ylabel(\"learning_rate\")\n",
        "plt.title(\"Learning_rate VS Number of Epochs\")\n",
        "\n",
        "# plotting MAD\n",
        "plt.figure()\n",
        "plt.plot(val_mad)\n",
        "plt.xlabel(\"Number of epochs\")\n",
        "plt.ylabel(\"Validation MAD\")\n",
        "plt.title(\"Validation MAD VS Number of Epochs\")\n",
        "\n",
        "# plotting FAD\n",
        "plt.figure()\n",
        "plt.plot(val_fad)\n",
        "plt.xlabel(\"Number of epochs\")\n",
        "plt.ylabel(\"Validation FAD\")\n",
        "plt.title(\"Validation FAD VS Number of Epochs\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "d8uaV3o2s-Zj"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "gpuClass": "premium",
    "kernelspec": {
      "display_name": "ml",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.9.6 | packaged by conda-forge | (default, Jul 11 2021, 03:35:11) \n[Clang 11.1.0 ]"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "08eac26dc1f80337b7d87e94e7159a5bad95c2e85f47efef91c61359b3afbfe9"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}