synthetic_data_using_transformer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e7aece68",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "49342578",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams.update({'font.size': 18})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "f1685a3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    " \n",
    "logging.basicConfig(filename = 'mem_with_transf_synth_train.log',\n",
    "                    level = logging.DEBUG,\n",
    "                    format = '%(asctime)s:%(levelname)s:%(name)s:%(message)s')\n",
    "logging.getLogger().addHandler(logging.StreamHandler())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "5ab172c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "7365253c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torchmetrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8cbd0bfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "956a1742",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.utils.data as data\n",
    "import torch.optim as optim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "fa3984bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "from torch.optim.lr_scheduler import StepLR\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from torch.utils.data import random_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9819926a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device: cuda:0\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(\"Device:\", device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ca85bf38",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scaled_dot_product(q, k, v, mask=None):\n",
    "    d_k = q.size()[-1]\n",
    "    attn_logits = torch.matmul(q, k.transpose(-2, -1))\n",
    "    attn_logits = attn_logits / math.sqrt(d_k)\n",
    "    if mask is not None:\n",
    "        attn_logits = attn_logits.masked_fill(mask == 0, -9e15)\n",
    "    attention = F.softmax(attn_logits, dim=-1)\n",
    "    values = torch.matmul(attention, v)\n",
    "    return values, attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "86a4959b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiheadAttention(nn.Module):\n",
    "\n",
    "    def __init__(self, input_dim, embed_dim, num_heads):\n",
    "        super().__init__()\n",
    "        assert embed_dim % num_heads == 0, \"Embedding dimension must be 0 modulo number of heads.\"\n",
    "\n",
    "        self.embed_dim = embed_dim\n",
    "        self.num_heads = num_heads\n",
    "        self.head_dim = embed_dim // num_heads\n",
    "\n",
    "        # Stack all weight matrices 1...h together for efficiency\n",
    "        # Note that in many implementations you see \"bias=False\" which is optional\n",
    "        self.qkv_proj = nn.Linear(input_dim, 3*embed_dim)\n",
    "        self.o_proj = nn.Linear(embed_dim, embed_dim)\n",
    "\n",
    "        self._reset_parameters()\n",
    "\n",
    "    def _reset_parameters(self):\n",
    "        # Original Transformer initialization, see PyTorch documentation\n",
    "        nn.init.xavier_uniform_(self.qkv_proj.weight)\n",
    "        self.qkv_proj.bias.data.fill_(0)\n",
    "        nn.init.xavier_uniform_(self.o_proj.weight)\n",
    "        self.o_proj.bias.data.fill_(0)\n",
    "\n",
    "    def forward(self, x, mask=None, return_attention=False):\n",
    "        batch_size, seq_length, embed_dim = x.size()\n",
    "        qkv = self.qkv_proj(x)\n",
    "\n",
    "        # Separate Q, K, V from linear output\n",
    "        qkv = qkv.reshape(batch_size, seq_length, self.num_heads, 3*self.head_dim)\n",
    "        qkv = qkv.permute(0, 2, 1, 3) # [Batch, Head, SeqLen, Dims]\n",
    "        q, k, v = qkv.chunk(3, dim=-1)\n",
    "\n",
    "        # Determine value outputs\n",
    "        values, attention = scaled_dot_product(q, k, v, mask=mask)\n",
    "        values = values.permute(0, 2, 1, 3) # [Batch, SeqLen, Head, Dims]\n",
    "        values = values.reshape(batch_size, seq_length, embed_dim)\n",
    "        o = self.o_proj(values)\n",
    "\n",
    "        if return_attention:\n",
    "            return o, attention\n",
    "        else:\n",
    "            return o"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "962b1a1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class EncoderBlock(nn.Module):\n",
    "\n",
    "    def __init__(self, input_dim, num_heads, dim_feedforward, dropout=0.0):\n",
    "        \"\"\"\n",
    "        Inputs:\n",
    "            input_dim - Dimensionality of the input\n",
    "            num_heads - Number of heads to use in the attention block\n",
    "            dim_feedforward - Dimensionality of the hidden layer in the MLP\n",
    "            dropout - Dropout probability to use in the dropout layers\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "\n",
    "        # Attention layer\n",
    "        self.self_attn = MultiheadAttention(input_dim, input_dim, num_heads)\n",
    "\n",
    "        # Two-layer MLP\n",
    "        self.linear_net = nn.Sequential(\n",
    "            nn.Linear(input_dim, dim_feedforward),\n",
    "            nn.Dropout(dropout),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(dim_feedforward, input_dim)\n",
    "        )\n",
    "\n",
    "        # Layers to apply in between the main layers\n",
    "        self.norm1 = nn.LayerNorm(input_dim)\n",
    "        self.norm2 = nn.LayerNorm(input_dim)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(self, x, mask=None):\n",
    "        # Attention part\n",
    "        attn_out = self.self_attn(x, mask=mask)\n",
    "        x = x + self.dropout(attn_out)\n",
    "        x = self.norm1(x)\n",
    "\n",
    "        # MLP part\n",
    "        linear_out = self.linear_net(x)\n",
    "        x = x + self.dropout(linear_out)\n",
    "        x = self.norm2(x)\n",
    "        \n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1d10f893",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerEncoder(nn.Module):\n",
    "\n",
    "    def __init__(self, num_layers, **block_args):\n",
    "        super().__init__()\n",
    "        self.layers = nn.ModuleList([EncoderBlock(**block_args) for _ in range(num_layers)])\n",
    "\n",
    "    def forward(self, x, mask=None):\n",
    "        for l in self.layers:\n",
    "            x = l(x, mask=mask)\n",
    "        return x\n",
    "\n",
    "    def get_attention_maps(self, x, mask=None):\n",
    "        attention_maps = []\n",
    "        for l in self.layers:\n",
    "            _, attn_map = l.self_attn(x, mask=mask, return_attention=True)\n",
    "            attention_maps.append(attn_map)\n",
    "            x = l(x)\n",
    "        return attention_maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ec06c8d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionalEncoding(nn.Module):\n",
    "\n",
    "    def __init__(self, d_model, max_len=5000):\n",
    "        \"\"\"\n",
    "        Inputs\n",
    "            d_model - Hidden dimensionality of the input.\n",
    "            max_len - Maximum length of a sequence to expect.\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "\n",
    "        # Create matrix of [SeqLen, HiddenDim] representing the positional encoding for max_len inputs\n",
    "        pe = torch.zeros(max_len, d_model)\n",
    "        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)\n",
    "        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))\n",
    "        pe[:, 0::2] = torch.sin(position * div_term)\n",
    "        pe[:, 1::2] = torch.cos(position * div_term)\n",
    "        pe = pe.unsqueeze(0)\n",
    "\n",
    "        # register_buffer => Tensor which is not a parameter, but should be part of the modules state.\n",
    "        # Used for tensors that need to be on the same device as the module.\n",
    "        # persistent=False tells PyTorch to not add the buffer to the state dict (e.g. when we save the model)\n",
    "        self.register_buffer('pe', pe, persistent=False)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x + self.pe[:, :x.size(1)]\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "066d5aaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CosineWarmupScheduler(optim.lr_scheduler._LRScheduler):\n",
    "\n",
    "    def __init__(self, optimizer, warmup, max_iters):\n",
    "        self.warmup = warmup\n",
    "        self.max_num_iters = max_iters\n",
    "        super().__init__(optimizer)\n",
    "\n",
    "    def get_lr(self):\n",
    "        lr_factor = self.get_lr_factor(epoch=self.last_epoch)\n",
    "        return [base_lr * lr_factor for base_lr in self.base_lrs]\n",
    "\n",
    "    def get_lr_factor(self, epoch):\n",
    "        lr_factor = 0.5 * (1 + np.cos(np.pi * epoch / self.max_num_iters))\n",
    "        if epoch <= self.warmup:\n",
    "            lr_factor *= epoch * 1.0 / self.warmup\n",
    "        return lr_factor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "48d4f81e",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_context_query = np.load('train_context_query.npy', allow_pickle=True)\n",
    "val_context_query = np.load('val_context_query.npy', allow_pickle=True)\n",
    "test_context_query = np.load('test_context_query.npy', allow_pickle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "dbe1caeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train= pd.read_json('synthetic_train.json')\n",
    "df_val = pd.read_json('synthetic_val.json')\n",
    "df_test = pd.read_json('synthetic_test.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "af80a5b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>index</th>\n",
       "      <th>seq_len</th>\n",
       "      <th>seq</th>\n",
       "      <th>rep_token_first_pos</th>\n",
       "      <th>query_token</th>\n",
       "      <th>target_val</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>44654</th>\n",
       "      <td>44654</td>\n",
       "      <td>25</td>\n",
       "      <td>[81  9 32 70 73 68 19 85  1 30 15 45 82 64 38 ...</td>\n",
       "      <td>12</td>\n",
       "      <td>82</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>85524</th>\n",
       "      <td>85524</td>\n",
       "      <td>45</td>\n",
       "      <td>[54 48 92 66 35 94 53 95 24 49  4  5 72 62 15 ...</td>\n",
       "      <td>20</td>\n",
       "      <td>85</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9508</th>\n",
       "      <td>9508</td>\n",
       "      <td>7</td>\n",
       "      <td>[54 30  8  1 19 71 73]</td>\n",
       "      <td>0</td>\n",
       "      <td>54</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21160</th>\n",
       "      <td>21160</td>\n",
       "      <td>13</td>\n",
       "      <td>[68  5 84 25 39 12 35 15 97 31 64 88 38]</td>\n",
       "      <td>8</td>\n",
       "      <td>97</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>193670</th>\n",
       "      <td>193670</td>\n",
       "      <td>99</td>\n",
       "      <td>[44 50 31 65 97 60 95 40 42 30 14 62 10 33 72 ...</td>\n",
       "      <td>62</td>\n",
       "      <td>93</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         index  seq_len                                                seq  \\\n",
       "44654    44654       25  [81  9 32 70 73 68 19 85  1 30 15 45 82 64 38 ...   \n",
       "85524    85524       45  [54 48 92 66 35 94 53 95 24 49  4  5 72 62 15 ...   \n",
       "9508      9508        7                             [54 30  8  1 19 71 73]   \n",
       "21160    21160       13           [68  5 84 25 39 12 35 15 97 31 64 88 38]   \n",
       "193670  193670       99  [44 50 31 65 97 60 95 40 42 30 14 62 10 33 72 ...   \n",
       "\n",
       "        rep_token_first_pos  query_token  target_val  \n",
       "44654                    12           82           1  \n",
       "85524                    20           85           1  \n",
       "9508                      0           54           1  \n",
       "21160                     8           97           1  \n",
       "193670                   62           93           1  "
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a295f75b",
   "metadata": {},
   "outputs": [],
   "source": [
    "INP_PATH = '/data/sherin/'\n",
    "orth_vectors = np.load(\n",
    "    INP_PATH + 'orthonormal_vectors_512.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "579e483c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_tensors(inp, Orth):\n",
    "    C = np.zeros((len(inp), 100, 512))\n",
    "    Q = np.zeros((len(inp), 512))\n",
    "    for idx, c_q in enumerate(inp):\n",
    "        Q[idx] = Orth[c_q[-1]]\n",
    "        C[idx,100 - len(c_q)+1:,:] = Orth[c_q[:-1]]\n",
    "    return C, Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1886507a",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_C, train_Q = get_tensors(train_context_query, orth_vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "673ef7de",
   "metadata": {},
   "outputs": [],
   "source": [
    "val_C, val_Q = get_tensors(val_context_query, orth_vectors)\n",
    "test_C, test_Q = get_tensors(test_context_query, orth_vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "be409db6",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_label = df_train['target_val'].values\n",
    "val_label = df_val['target_val'].values\n",
    "test_label = df_test['target_val'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "97b3eb92",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data_loader(context_reps, query_reps, label, batch_size, shuffle):\n",
    "    data_set = TensorDataset(context_reps, query_reps, label)\n",
    "    loader = DataLoader(data_set, batch_size=batch_size, shuffle=shuffle)\n",
    "    return loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c3f20e56",
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "34c5242f",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = get_data_loader(torch.tensor(train_C).float(), torch.tensor(train_Q).float(),\n",
    "                               torch.tensor(train_label), batch_size, shuffle=True)\n",
    "val_loader = get_data_loader(torch.tensor(val_C).float(), torch.tensor(val_Q).float(),\n",
    "                             torch.tensor(val_label), batch_size, shuffle=False)\n",
    "test_loader = get_data_loader(torch.tensor(test_C).float(), torch.tensor(test_Q).float(),\n",
    "                              torch.tensor(test_label), batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "ac9e0227",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerPredictor(nn.Module):\n",
    "\n",
    "    def __init__(self, input_dim=512, model_dim=32,\n",
    "                 num_heads=1, num_layers=1,\n",
    "                 dropout=0.0, input_dropout=0.0):\n",
    "\n",
    "        super().__init__()\n",
    "\n",
    "        # Input dim -> Model dim\n",
    "        self.input_net = nn.Sequential(\n",
    "            #nn.Dropout(input_dropout),\n",
    "            nn.Linear(input_dim, model_dim)\n",
    "        )\n",
    "        # Positional encoding for sequences\n",
    "        #self.positional_encoding = PositionalEncoding(d_model=model_dim)\n",
    "        # Transformer\n",
    "        self.transformer = TransformerEncoder(num_layers=num_layers,\n",
    "                                              input_dim=model_dim,\n",
    "                                              dim_feedforward=2*model_dim,\n",
    "                                              num_heads=num_heads,\n",
    "                                              dropout=dropout)\n",
    "\n",
    "    def forward(self, x, y):\n",
    "        x = self.input_net(x)\n",
    "        y = self.input_net(y)\n",
    "        #x = self.positional_encoding(x)\n",
    "        #y = self.positional_encoding(y)\n",
    "        x = self.transformer(x)\n",
    "        #print(x.shape)\n",
    "        #print(y.shape)\n",
    "        #op = torch.sum(x[:,-1,:]*y, dim=1)\n",
    "        op = torch.sum(torch.sum(x, dim=1)*y, dim=1)\n",
    "        return op\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "6a373eea",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = TransformerPredictor().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "d51916fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 100\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.01)\n",
    "scheduler = StepLR(optimizer, step_size=5, gamma=0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "eca5300e",
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint_path = '/data/sherin/checkpoint_lm/chkpt_synth_tran_steplr_recall_best.pt.tar'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "b4e8fc3c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [01:08<00:00, 10.89it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:52<00:00,  6.01it/s]\n",
      "saving best model\n",
      "curr_lr: 0.01\n",
      "[1] Training loss: 1.381 Training accuracy : 0.524\n",
      "[1] Validation loss: 0.686 Validation accuracy : 0.519\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:30<00:00, 24.48it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 73.31it/s]\n",
      "saving best model\n",
      "curr_lr: 0.01\n",
      "[2] Training loss: 0.706 Training accuracy : 0.546\n",
      "[2] Validation loss: 0.780 Validation accuracy : 0.553\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 60.15it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 101.76it/s]\n",
      "saving best model\n",
      "curr_lr: 0.01\n",
      "[3] Training loss: 0.689 Training accuracy : 0.577\n",
      "[3] Validation loss: 0.658 Validation accuracy : 0.600\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.08it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 71.43it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.01\n",
      "[4] Training loss: 0.681 Training accuracy : 0.602\n",
      "[4] Validation loss: 0.687 Validation accuracy : 0.596\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 64.06it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 95.90it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.01\n",
      "[5] Training loss: 0.679 Training accuracy : 0.610\n",
      "[5] Validation loss: 0.741 Validation accuracy : 0.597\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 60.80it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 70.87it/s]\n",
      "saving best model\n",
      "curr_lr: 0.008\n",
      "[6] Training loss: 0.649 Training accuracy : 0.636\n",
      "[6] Validation loss: 0.706 Validation accuracy : 0.609\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 64.10it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 96.26it/s]\n",
      "saving best model\n",
      "curr_lr: 0.008\n",
      "[7] Training loss: 0.647 Training accuracy : 0.647\n",
      "[7] Validation loss: 0.685 Validation accuracy : 0.619\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 62.85it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 96.57it/s]\n",
      "saving best model\n",
      "curr_lr: 0.008\n",
      "[8] Training loss: 0.649 Training accuracy : 0.649\n",
      "[8] Validation loss: 0.700 Validation accuracy : 0.633\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 66.28it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 77.10it/s]\n",
      "saving best model\n",
      "curr_lr: 0.008\n",
      "[9] Training loss: 0.661 Training accuracy : 0.643\n",
      "[9] Validation loss: 0.674 Validation accuracy : 0.638\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 67.38it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 98.23it/s]\n",
      "saving best model\n",
      "curr_lr: 0.008\n",
      "[10] Training loss: 0.650 Training accuracy : 0.653\n",
      "[10] Validation loss: 0.659 Validation accuracy : 0.648\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 60.31it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 68.25it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0064\n",
      "[11] Training loss: 0.612 Training accuracy : 0.678\n",
      "[11] Validation loss: 0.594 Validation accuracy : 0.687\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 52.52it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 75.82it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0064\n",
      "[12] Training loss: 0.607 Training accuracy : 0.685\n",
      "[12] Validation loss: 0.637 Validation accuracy : 0.663\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:16<00:00, 44.90it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 69.00it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0064\n",
      "[13] Training loss: 0.593 Training accuracy : 0.697\n",
      "[13] Validation loss: 0.623 Validation accuracy : 0.682\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 66.45it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 100.54it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0064\n",
      "[14] Training loss: 0.584 Training accuracy : 0.703\n",
      "[14] Validation loss: 0.722 Validation accuracy : 0.656\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 61.75it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 75.34it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0064\n",
      "[15] Training loss: 0.585 Training accuracy : 0.706\n",
      "[15] Validation loss: 0.621 Validation accuracy : 0.686\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:10<00:00, 69.99it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 98.61it/s]\n",
      "saving best model\n",
      "curr_lr: 0.00512\n",
      "[16] Training loss: 0.538 Training accuracy : 0.731\n",
      "[16] Validation loss: 0.629 Validation accuracy : 0.702\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 61.65it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 102.05it/s]\n",
      "saving best model\n",
      "curr_lr: 0.00512\n",
      "[17] Training loss: 0.527 Training accuracy : 0.740\n",
      "[17] Validation loss: 0.584 Validation accuracy : 0.710\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 57.58it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 73.37it/s]\n",
      "saving best model\n",
      "curr_lr: 0.00512\n",
      "[18] Training loss: 0.525 Training accuracy : 0.741\n",
      "[18] Validation loss: 0.587 Validation accuracy : 0.711\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:10<00:00, 70.09it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:02<00:00, 107.08it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00512\n",
      "[19] Training loss: 0.524 Training accuracy : 0.743\n",
      "[19] Validation loss: 0.604 Validation accuracy : 0.709\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 64.08it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 71.90it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00512\n",
      "[20] Training loss: 0.519 Training accuracy : 0.746\n",
      "[20] Validation loss: 0.639 Validation accuracy : 0.694\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 65.05it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 90.64it/s]\n",
      "saving best model\n",
      "curr_lr: 0.004096000000000001\n",
      "[21] Training loss: 0.478 Training accuracy : 0.768\n",
      "[21] Validation loss: 0.541 Validation accuracy : 0.734\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 54.88it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 68.24it/s]\n",
      "saving best model\n",
      "curr_lr: 0.004096000000000001\n",
      "[22] Training loss: 0.475 Training accuracy : 0.770\n",
      "[22] Validation loss: 0.544 Validation accuracy : 0.737\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 61.80it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 96.21it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.004096000000000001\n",
      "[23] Training loss: 0.477 Training accuracy : 0.771\n",
      "[23] Validation loss: 0.573 Validation accuracy : 0.723\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 65.05it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 100.34it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.004096000000000001\n",
      "[24] Training loss: 0.474 Training accuracy : 0.773\n",
      "[24] Validation loss: 0.566 Validation accuracy : 0.729\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.39it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 70.33it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.004096000000000001\n",
      "[25] Training loss: 0.469 Training accuracy : 0.777\n",
      "[25] Validation loss: 0.598 Validation accuracy : 0.716\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:10<00:00, 67.83it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 104.49it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0032768000000000007\n",
      "[26] Training loss: 0.441 Training accuracy : 0.788\n",
      "[26] Validation loss: 0.507 Validation accuracy : 0.759\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 59.25it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 66.53it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0032768000000000007\n",
      "[27] Training loss: 0.436 Training accuracy : 0.793\n",
      "[27] Validation loss: 0.554 Validation accuracy : 0.741\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 63.83it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 100.76it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0032768000000000007\n",
      "[28] Training loss: 0.436 Training accuracy : 0.794\n",
      "[28] Validation loss: 0.556 Validation accuracy : 0.743\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 59.37it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 79.03it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0032768000000000007\n",
      "[29] Training loss: 0.435 Training accuracy : 0.795\n",
      "[29] Validation loss: 0.533 Validation accuracy : 0.748\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 62.04it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 96.29it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0032768000000000007\n",
      "[30] Training loss: 0.436 Training accuracy : 0.793\n",
      "[30] Validation loss: 0.590 Validation accuracy : 0.727\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 57.56it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 100.31it/s]\n",
      "saving best model\n",
      "curr_lr: 0.002621440000000001\n",
      "[31] Training loss: 0.412 Training accuracy : 0.805\n",
      "[31] Validation loss: 0.518 Validation accuracy : 0.760\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 61.94it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 71.95it/s]\n",
      "saving best model\n",
      "curr_lr: 0.002621440000000001\n",
      "[32] Training loss: 0.405 Training accuracy : 0.809\n",
      "[32] Validation loss: 0.521 Validation accuracy : 0.760\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 60.09it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 94.38it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.002621440000000001\n",
      "[33] Training loss: 0.406 Training accuracy : 0.810\n",
      "[33] Validation loss: 0.543 Validation accuracy : 0.752\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 57.05it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 73.30it/s]\n",
      "saving best model\n",
      "curr_lr: 0.002621440000000001\n",
      "[34] Training loss: 0.406 Training accuracy : 0.810\n",
      "[34] Validation loss: 0.501 Validation accuracy : 0.765\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.91it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 93.35it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.002621440000000001\n",
      "[35] Training loss: 0.403 Training accuracy : 0.809\n",
      "[35] Validation loss: 0.520 Validation accuracy : 0.764\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 55.22it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 65.05it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.002097152000000001\n",
      "[36] Training loss: 0.385 Training accuracy : 0.818\n",
      "[36] Validation loss: 0.516 Validation accuracy : 0.761\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 63.39it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 98.64it/s]\n",
      "saving best model\n",
      "curr_lr: 0.002097152000000001\n",
      "[37] Training loss: 0.384 Training accuracy : 0.821\n",
      "[37] Validation loss: 0.507 Validation accuracy : 0.767\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 57.75it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 68.20it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.002097152000000001\n",
      "[38] Training loss: 0.379 Training accuracy : 0.824\n",
      "[38] Validation loss: 0.509 Validation accuracy : 0.761\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 59.17it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 100.06it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.002097152000000001\n",
      "[39] Training loss: 0.380 Training accuracy : 0.823\n",
      "[39] Validation loss: 0.530 Validation accuracy : 0.759\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 52.48it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 68.25it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.002097152000000001\n",
      "[40] Training loss: 0.383 Training accuracy : 0.821\n",
      "[40] Validation loss: 0.508 Validation accuracy : 0.764\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 63.15it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 99.02it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.001677721600000001\n",
      "[41] Training loss: 0.362 Training accuracy : 0.831\n",
      "[41] Validation loss: 0.519 Validation accuracy : 0.767\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 56.00it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 74.56it/s]\n",
      "saving best model\n",
      "curr_lr: 0.001677721600000001\n",
      "[42] Training loss: 0.364 Training accuracy : 0.832\n",
      "[42] Validation loss: 0.519 Validation accuracy : 0.770\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 60.43it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 91.92it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.001677721600000001\n",
      "[43] Training loss: 0.363 Training accuracy : 0.832\n",
      "[43] Validation loss: 0.518 Validation accuracy : 0.769\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.90it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 99.01it/s]\n",
      "saving best model\n",
      "curr_lr: 0.001677721600000001\n",
      "[44] Training loss: 0.364 Training accuracy : 0.831\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[44] Validation loss: 0.525 Validation accuracy : 0.771\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.27it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 71.31it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.001677721600000001\n",
      "[45] Training loss: 0.360 Training accuracy : 0.833\n",
      "[45] Validation loss: 0.516 Validation accuracy : 0.770\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 63.90it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 98.37it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0013421772800000008\n",
      "[46] Training loss: 0.348 Training accuracy : 0.839\n",
      "[46] Validation loss: 0.519 Validation accuracy : 0.771\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 54.03it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 64.04it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0013421772800000008\n",
      "[47] Training loss: 0.347 Training accuracy : 0.838\n",
      "[47] Validation loss: 0.510 Validation accuracy : 0.778\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 55.54it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 90.25it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0013421772800000008\n",
      "[48] Training loss: 0.348 Training accuracy : 0.838\n",
      "[48] Validation loss: 0.519 Validation accuracy : 0.773\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.01it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 61.60it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0013421772800000008\n",
      "[49] Training loss: 0.346 Training accuracy : 0.840\n",
      "[49] Validation loss: 0.528 Validation accuracy : 0.771\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 59.30it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 90.87it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0013421772800000008\n",
      "[50] Training loss: 0.344 Training accuracy : 0.840\n",
      "[50] Validation loss: 0.500 Validation accuracy : 0.779\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 54.23it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 64.15it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0010737418240000006\n",
      "[51] Training loss: 0.336 Training accuracy : 0.845\n",
      "[51] Validation loss: 0.512 Validation accuracy : 0.779\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 63.88it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 99.46it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0010737418240000006\n",
      "[52] Training loss: 0.336 Training accuracy : 0.845\n",
      "[52] Validation loss: 0.519 Validation accuracy : 0.777\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 55.67it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 62.35it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0010737418240000006\n",
      "[53] Training loss: 0.334 Training accuracy : 0.847\n",
      "[53] Validation loss: 0.525 Validation accuracy : 0.772\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 59.21it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 99.31it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0010737418240000006\n",
      "[54] Training loss: 0.335 Training accuracy : 0.845\n",
      "[54] Validation loss: 0.520 Validation accuracy : 0.775\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.94it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 70.13it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0010737418240000006\n",
      "[55] Training loss: 0.334 Training accuracy : 0.846\n",
      "[55] Validation loss: 0.519 Validation accuracy : 0.777\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:10<00:00, 69.68it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 100.95it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0008589934592000006\n",
      "[56] Training loss: 0.325 Training accuracy : 0.851\n",
      "[56] Validation loss: 0.518 Validation accuracy : 0.778\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 61.82it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 62.75it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0008589934592000006\n",
      "[57] Training loss: 0.325 Training accuracy : 0.850\n",
      "[57] Validation loss: 0.516 Validation accuracy : 0.780\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 59.75it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 92.78it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0008589934592000006\n",
      "[58] Training loss: 0.324 Training accuracy : 0.851\n",
      "[58] Validation loss: 0.520 Validation accuracy : 0.779\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 53.88it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 70.93it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0008589934592000006\n",
      "[59] Training loss: 0.323 Training accuracy : 0.852\n",
      "[59] Validation loss: 0.520 Validation accuracy : 0.776\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 65.30it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 95.32it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0008589934592000006\n",
      "[60] Training loss: 0.324 Training accuracy : 0.850\n",
      "[60] Validation loss: 0.523 Validation accuracy : 0.778\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 51.83it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 64.58it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0006871947673600005\n",
      "[61] Training loss: 0.316 Training accuracy : 0.855\n",
      "[61] Validation loss: 0.516 Validation accuracy : 0.779\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 62.13it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 100.21it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0006871947673600005\n",
      "[62] Training loss: 0.315 Training accuracy : 0.855\n",
      "[62] Validation loss: 0.523 Validation accuracy : 0.780\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 63.47it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 65.11it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0006871947673600005\n",
      "[63] Training loss: 0.316 Training accuracy : 0.854\n",
      "[63] Validation loss: 0.528 Validation accuracy : 0.778\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.97it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 92.49it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0006871947673600005\n",
      "[64] Training loss: 0.315 Training accuracy : 0.855\n",
      "[64] Validation loss: 0.529 Validation accuracy : 0.778\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 55.55it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 66.24it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0006871947673600005\n",
      "[65] Training loss: 0.316 Training accuracy : 0.855\n",
      "[65] Validation loss: 0.528 Validation accuracy : 0.777\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 59.27it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 86.69it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0005497558138880005\n",
      "[66] Training loss: 0.308 Training accuracy : 0.859\n",
      "[66] Validation loss: 0.527 Validation accuracy : 0.779\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 57.56it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 63.00it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0005497558138880005\n",
      "[67] Training loss: 0.309 Training accuracy : 0.858\n",
      "[67] Validation loss: 0.524 Validation accuracy : 0.780\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 62.07it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 101.71it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0005497558138880005\n",
      "[68] Training loss: 0.308 Training accuracy : 0.858\n",
      "[68] Validation loss: 0.530 Validation accuracy : 0.778\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 54.34it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 66.20it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0005497558138880005\n",
      "[69] Training loss: 0.307 Training accuracy : 0.860\n",
      "[69] Validation loss: 0.526 Validation accuracy : 0.782\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:22<00:00, 32.49it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 68.09it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0005497558138880005\n",
      "[70] Training loss: 0.308 Training accuracy : 0.859\n",
      "[70] Validation loss: 0.525 Validation accuracy : 0.780\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 62.92it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 97.57it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0004398046511104004\n",
      "[71] Training loss: 0.303 Training accuracy : 0.862\n",
      "[71] Validation loss: 0.525 Validation accuracy : 0.780\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 57.87it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 67.94it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0004398046511104004\n",
      "[72] Training loss: 0.303 Training accuracy : 0.862\n",
      "[72] Validation loss: 0.520 Validation accuracy : 0.782\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:19<00:00, 38.20it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 67.69it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0004398046511104004\n",
      "[73] Training loss: 0.302 Training accuracy : 0.862\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[73] Validation loss: 0.533 Validation accuracy : 0.780\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 52.01it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 67.33it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0004398046511104004\n",
      "[74] Training loss: 0.302 Training accuracy : 0.862\n",
      "[74] Validation loss: 0.533 Validation accuracy : 0.783\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.41it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 101.79it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0004398046511104004\n",
      "[75] Training loss: 0.302 Training accuracy : 0.863\n",
      "[75] Validation loss: 0.527 Validation accuracy : 0.780\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 49.71it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 61.50it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00035184372088832035\n",
      "[76] Training loss: 0.298 Training accuracy : 0.864\n",
      "[76] Validation loss: 0.526 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:11<00:00, 61.98it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 93.00it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00035184372088832035\n",
      "[77] Training loss: 0.297 Training accuracy : 0.865\n",
      "[77] Validation loss: 0.536 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 53.97it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 72.31it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00035184372088832035\n",
      "[78] Training loss: 0.298 Training accuracy : 0.864\n",
      "[78] Validation loss: 0.530 Validation accuracy : 0.782\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 51.30it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 69.56it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00035184372088832035\n",
      "[79] Training loss: 0.297 Training accuracy : 0.865\n",
      "[79] Validation loss: 0.537 Validation accuracy : 0.779\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 53.84it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 90.56it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00035184372088832035\n",
      "[80] Training loss: 0.297 Training accuracy : 0.865\n",
      "[80] Validation loss: 0.533 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 50.69it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 75.76it/s]\n",
      "saving best model\n",
      "curr_lr: 0.0002814749767106563\n",
      "[81] Training loss: 0.294 Training accuracy : 0.866\n",
      "[81] Validation loss: 0.539 Validation accuracy : 0.783\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 51.63it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 68.85it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0002814749767106563\n",
      "[82] Training loss: 0.294 Training accuracy : 0.866\n",
      "[82] Validation loss: 0.541 Validation accuracy : 0.782\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:12<00:00, 58.64it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 98.37it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0002814749767106563\n",
      "[83] Training loss: 0.294 Training accuracy : 0.866\n",
      "[83] Validation loss: 0.535 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 53.33it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 66.59it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0002814749767106563\n",
      "[84] Training loss: 0.294 Training accuracy : 0.867\n",
      "[84] Validation loss: 0.534 Validation accuracy : 0.780\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 51.62it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 61.06it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.0002814749767106563\n",
      "[85] Training loss: 0.293 Training accuracy : 0.866\n",
      "[85] Validation loss: 0.537 Validation accuracy : 0.782\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 56.54it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 99.20it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00022517998136852504\n",
      "[86] Training loss: 0.291 Training accuracy : 0.868\n",
      "[86] Validation loss: 0.537 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 52.57it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 68.20it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00022517998136852504\n",
      "[87] Training loss: 0.291 Training accuracy : 0.868\n",
      "[87] Validation loss: 0.539 Validation accuracy : 0.783\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:21<00:00, 34.96it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 65.55it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00022517998136852504\n",
      "[88] Training loss: 0.291 Training accuracy : 0.868\n",
      "[88] Validation loss: 0.542 Validation accuracy : 0.782\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 51.78it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 69.22it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00022517998136852504\n",
      "[89] Training loss: 0.291 Training accuracy : 0.869\n",
      "[89] Validation loss: 0.539 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:16<00:00, 43.77it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 62.10it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00022517998136852504\n",
      "[90] Training loss: 0.290 Training accuracy : 0.869\n",
      "[90] Validation loss: 0.541 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:17<00:00, 41.58it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 62.60it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00018014398509482005\n",
      "[91] Training loss: 0.288 Training accuracy : 0.870\n",
      "[91] Validation loss: 0.534 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 52.74it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 90.33it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00018014398509482005\n",
      "[92] Training loss: 0.288 Training accuracy : 0.870\n",
      "[92] Validation loss: 0.544 Validation accuracy : 0.783\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 51.06it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 62.60it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00018014398509482005\n",
      "[93] Training loss: 0.288 Training accuracy : 0.870\n",
      "[93] Validation loss: 0.543 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 56.07it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 72.59it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00018014398509482005\n",
      "[94] Training loss: 0.288 Training accuracy : 0.870\n",
      "[94] Validation loss: 0.539 Validation accuracy : 0.782\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:29<00:00, 25.04it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 65.63it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00018014398509482005\n",
      "[95] Training loss: 0.288 Training accuracy : 0.869\n",
      "[95] Validation loss: 0.544 Validation accuracy : 0.782\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:14<00:00, 52.37it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 59.83it/s]\n",
      "saving best model\n",
      "curr_lr: 0.00014411518807585605\n",
      "[96] Training loss: 0.286 Training accuracy : 0.870\n",
      "[96] Validation loss: 0.537 Validation accuracy : 0.784\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:18<00:00, 40.55it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 65.18it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00014411518807585605\n",
      "[97] Training loss: 0.286 Training accuracy : 0.870\n",
      "[97] Validation loss: 0.544 Validation accuracy : 0.783\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:21<00:00, 33.76it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:05<00:00, 61.59it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00014411518807585605\n",
      "[98] Training loss: 0.286 Training accuracy : 0.871\n",
      "[98] Validation loss: 0.544 Validation accuracy : 0.783\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:13<00:00, 55.57it/s]\n",
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:03<00:00, 100.03it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00014411518807585605\n",
      "[99] Training loss: 0.286 Training accuracy : 0.871\n",
      "[99] Validation loss: 0.544 Validation accuracy : 0.781\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 742/742 [00:16<00:00, 45.87it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 318/318 [00:04<00:00, 64.72it/s]\n",
      "not saving the model\n",
      "curr_lr: 0.00014411518807585605\n",
      "[100] Training loss: 0.286 Training accuracy : 0.870\n",
      "[100] Validation loss: 0.541 Validation accuracy : 0.782\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "epoch_loss_list = []\n",
    "accuracy_list = []\n",
    "val_loss_list = []\n",
    "val_acc_list = []\n",
    "valid_acc_max = 0 \n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    train_count = 0\n",
    "    model.train()\n",
    "    epoch_loss = 0.0\n",
    "    accuracy = 0.0\n",
    "    \n",
    "\n",
    "    for context, query, labels in tqdm(train_loader):\n",
    "        train_count = train_count+1\n",
    "        context = context.to(device)\n",
    "        query = query.to(device)    \n",
    "        target = labels.to(device)\n",
    "        label = labels.float().to(device)\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = model(context, query)\n",
    "        loss = criterion(outputs, label)\n",
    "        loss.backward()\n",
    "\n",
    "        optimizer.step()\n",
    "        \n",
    "        epoch_loss += loss.item()\n",
    "        accuracy += torchmetrics.functional.accuracy(outputs, target, threshold=0.5).item()\n",
    "\n",
    "    \n",
    "    model.eval()\n",
    "    val_loss = 0.0\n",
    "    val_acc = 0.0\n",
    "    \n",
    "    test_count = 0\n",
    "    for context, query, labels in tqdm(val_loader):\n",
    "        test_count = test_count + 1\n",
    "        context = context.to(device)\n",
    "        query = query.to(device)\n",
    "        target = labels.to(device)\n",
    "        label = labels.float().to(device)\n",
    "        \n",
    "        outputs = model(context, query)\n",
    "        loss = criterion(outputs, label)\n",
    "        val_loss += loss.item()\n",
    "        val_acc += torchmetrics.functional.accuracy(outputs, target, threshold=0.5).item()\n",
    "        \n",
    "    accuracy = accuracy / train_count\n",
    "    epoch_loss = epoch_loss / train_count\n",
    "    val_loss = val_loss / test_count\n",
    "    val_acc = val_acc / test_count\n",
    "    \n",
    "    if val_acc > valid_acc_max:\n",
    "        logging.info(\"saving best model\")\n",
    "        torch.save({\n",
    "            'epoch': epoch,\n",
    "            'model_state_dict': model.state_dict(),\n",
    "            'optimizer_state_dict': optimizer.state_dict(),\n",
    "            'loss': val_loss,\n",
    "            'accuracy': val_acc,\n",
    "            }, checkpoint_path)\n",
    "        valid_acc_max = val_acc\n",
    "    else:\n",
    "        logging.info(\"not saving the model\")\n",
    "    \n",
    "    curr_lr = optimizer.param_groups[0]['lr']\n",
    "    logging.info(f'curr_lr: {curr_lr}')\n",
    "    logging.info(f'[{epoch + 1}] Training loss: {epoch_loss:.3f} Training accuracy : {accuracy:.3f}')\n",
    "    logging.info(f'[{epoch + 1}] Validation loss: {val_loss:.3f} Validation accuracy : {val_acc:.3f}')\n",
    "    epoch_loss_list.append(epoch_loss)\n",
    "    accuracy_list.append(accuracy)\n",
    "    val_loss_list.append(val_loss)\n",
    "    val_acc_list.append(val_acc)\n",
    "    \n",
    "    scheduler.step()\n",
    "\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "a2842d1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finished\n"
     ]
    }
   ],
   "source": [
    "print(\"finished\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "62c46c69",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TransformerPredictor(\n",
       "  (input_net): Sequential(\n",
       "    (0): Linear(in_features=512, out_features=32, bias=True)\n",
       "  )\n",
       "  (transformer): TransformerEncoder(\n",
       "    (layers): ModuleList(\n",
       "      (0): EncoderBlock(\n",
       "        (self_attn): MultiheadAttention(\n",
       "          (qkv_proj): Linear(in_features=32, out_features=96, bias=True)\n",
       "          (o_proj): Linear(in_features=32, out_features=32, bias=True)\n",
       "        )\n",
       "        (linear_net): Sequential(\n",
       "          (0): Linear(in_features=32, out_features=64, bias=True)\n",
       "          (1): Dropout(p=0.0, inplace=False)\n",
       "          (2): ReLU(inplace=True)\n",
       "          (3): Linear(in_features=64, out_features=32, bias=True)\n",
       "        )\n",
       "        (norm1): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "        (norm2): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
       "        (dropout): Dropout(p=0.0, inplace=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PATH = checkpoint_path\n",
    "checkpoint = torch.load(PATH)\n",
    "model.load_state_dict(checkpoint['model_state_dict'])\n",
    "optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "epoch = checkpoint['epoch']\n",
    "loss = checkpoint['loss']\n",
    "acc = checkpoint['accuracy']\n",
    "\n",
    "# inferece\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "a9c40b9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7835763636625038\n"
     ]
    }
   ],
   "source": [
    "print(acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "5dcadc81",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 455/455 [01:58<00:00,  3.86it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The test accuracy is 0.7847413004099668\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "test_count = 0\n",
    "output_logits_trans = []\n",
    "test_acc = 0\n",
    "for context, query, labels in tqdm(test_loader):\n",
    "    test_count = test_count + 1\n",
    "    context = context.to(device)\n",
    "    query = query.to(device)\n",
    "    target = labels.to(device)\n",
    "    label = labels.float().to(device)\n",
    "\n",
    "    outputs = model(context, query)\n",
    "    output_logits = outputs.detach().cpu().numpy()\n",
    "    test_acc += torchmetrics.functional.accuracy(outputs, target, threshold=0.5).item()\n",
    "    output_logits_trans.append(output_logits)\n",
    "\n",
    "accuracy = test_acc/test_count\n",
    "print(\"The test accuracy is {}\".format(accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "bf8a11f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_output_logits_trans = np.hstack(output_logits_trans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "225304d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "trans_pred = torch.sigmoid(torch.tensor(test_output_logits_trans))\n",
    "trans_pred_label = 1.0 * (trans_pred > 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "7440ab07",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(trans_pred, 'trans_pred.pt')\n",
    "torch.save(trans_pred_label, 'trans_pred_label.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a87edeb",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}