att_gru_jhmdb.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "import torchvision.models as pretrained\n",
    "from torchvision import transforms\n",
    "from tqdm import tqdm\n",
    "\n",
    "import requests\n",
    "from PIL import Image\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import imageio\n",
    "import cv2\n",
    "import os\n",
    "from torch.utils.data import Dataset, DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "print(f\"Using device: {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "IMG_SIZE = 64\n",
    "BATCH_SIZE = 8\n",
    "EPOCHS = 10\n",
    "\n",
    "MAX_SEQ_LENGTH = 20\n",
    "NUM_FEATURES = (IMG_SIZE**2)*3\n",
    "LEARNING_RATE = 0.001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = []\n",
    "data = []\n",
    "\n",
    "for label in os.listdir('./JHMDB_video/ReCompress_Videos/'):\n",
    "    labels.append(label)\n",
    "    for video in os.listdir(f'./JHMDB_video/ReCompress_Videos/{label}'):\n",
    "        if video.endswith('.avi'):\n",
    "            data.append((label, f'./JHMDB_video/ReCompress_Videos/{label}/{video}'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_map = {label:torch.tensor(idx) for idx, (label) in enumerate(labels)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VideoDataset(Dataset):\n",
    "\n",
    "    def __init__(self, video_dir_path):\n",
    "\n",
    "        self.resnet = pretrained.resnet50(pretrained=True).to(device)\n",
    "        self.resnet.eval()\n",
    "        self.layer = self.resnet.avgpool\n",
    "        self.video_embeddings = []\n",
    "        self.labels = []\n",
    "\n",
    "        self.transforms = transforms.Compose([\n",
    "            transforms.Resize((224, 224)),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[\n",
    "                0.229, 0.224, 0.255]),\n",
    "        ])\n",
    "\n",
    "        self.label_map = {}\n",
    "        def hook(module, inputs, outputs):\n",
    "            self.video_embeddings[-1].append(outputs.detach().cpu().squeeze())\n",
    "\n",
    "        self.handle = self.layer.register_forward_hook(hook)\n",
    "\n",
    "        for label in os.listdir(video_dir_path):\n",
    "            # print(label)\n",
    "            for video in tqdm(os.listdir(os.path.join(video_dir_path,label))): \n",
    "                if not video.endswith('.avi'):\n",
    "                    continue\n",
    "                frames = self.get_frames(os.path.join(video_dir_path, f'{label}/{video}'))\n",
    "                self.video_embeddings.append([])\n",
    "                self.labels.append(label)\n",
    "            \n",
    "                for frame in frames:\n",
    "                    inp = self.transforms(Image.fromarray(frame)).to(device).unsqueeze(0)\n",
    "                    self.resnet(inp)\n",
    "\n",
    "        self.handle.remove()\n",
    "        del self.handle\n",
    "        del self.resnet\n",
    "        del self.layer\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return torch.vstack(self.video_embeddings[idx]), self.label_map[self.labels[idx]]\n",
    "\n",
    "    def get_frames(self, path, max_frames=20):\n",
    "        vidObj = cv2.VideoCapture(path)\n",
    "        success = 1\n",
    "        frames = []\n",
    "        count = 0\n",
    "        while success:\n",
    "            success, image = vidObj.read()\n",
    "            count+=1\n",
    "            if not success or count > max_frames:\n",
    "                break\n",
    "            frames.append(image)\n",
    "        \n",
    "        for i in range(len(frames), max_frames+1):\n",
    "            frames.append(np.zeros_like(frames[0]))\n",
    "        return frames\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 42/42 [00:12<00:00,  3.32it/s]\n",
      "100%|██████████| 55/55 [00:13<00:00,  3.97it/s]\n",
      "100%|██████████| 40/40 [00:09<00:00,  4.27it/s]\n",
      "100%|██████████| 44/44 [00:10<00:00,  4.27it/s]\n",
      "100%|██████████| 46/46 [00:10<00:00,  4.19it/s]\n",
      "100%|██████████| 55/55 [00:13<00:00,  4.12it/s]\n",
      "100%|██████████| 39/39 [00:09<00:00,  4.15it/s]\n",
      "100%|██████████| 54/54 [00:13<00:00,  4.08it/s]\n",
      "100%|██████████| 40/40 [00:09<00:00,  4.07it/s]\n",
      "100%|██████████| 40/40 [00:09<00:00,  4.01it/s]\n",
      "100%|██████████| 40/40 [00:09<00:00,  4.12it/s]\n",
      "100%|██████████| 37/37 [00:08<00:00,  4.39it/s]\n",
      "100%|██████████| 53/53 [00:12<00:00,  4.11it/s]\n",
      "100%|██████████| 36/36 [00:08<00:00,  4.27it/s]\n",
      "100%|██████████| 42/42 [00:10<00:00,  4.11it/s]\n",
      "100%|██████████| 39/39 [00:09<00:00,  4.15it/s]\n",
      "100%|██████████| 41/41 [00:10<00:00,  3.97it/s]\n",
      "100%|██████████| 55/55 [00:13<00:00,  4.06it/s]\n",
      "100%|██████████| 48/48 [00:11<00:00,  4.11it/s]\n",
      "100%|██████████| 41/41 [00:10<00:00,  4.01it/s]\n",
      "100%|██████████| 42/42 [00:10<00:00,  4.08it/s]\n"
     ]
    }
   ],
   "source": [
    "dataset = VideoDataset('JHMDB_video/ReCompress_Videos')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset.label_map = label_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "928\n"
     ]
    }
   ],
   "source": [
    "print(len(dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_size = int(0.8 * len(dataset))\n",
    "test_size = len(dataset) - train_size\n",
    "train_dataset, test_dataset = torch.utils.data.random_split(\n",
    "    dataset, [train_size, test_size])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Attention(nn.Module):\n",
    "  def __init__(self, embedding_dim, n_hidden):\n",
    "    super().__init__()\n",
    "\n",
    "    self.embedding_dim = embedding_dim\n",
    "    self.n_hidden = n_hidden\n",
    "\n",
    "    self.wx = nn.Linear(self.embedding_dim, self.embedding_dim)\n",
    "    self.wh = nn.Linear(self.n_hidden, self.embedding_dim)\n",
    "    self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "  def forward(self, X, h):\n",
    "    out1 = self.wx(X)\n",
    "    out2 = self.wh(h)\n",
    "    a = self.sigmoid(out1+out2)\n",
    "    \n",
    "    return torch.mul(a,X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class EleAttG_GRU(nn.Module):\n",
    "  def __init__(self, embedding_dim, n_hidden=128, n_classes=None):\n",
    "    super().__init__()\n",
    "  \n",
    "    assert n_classes is not None\n",
    "    \n",
    "    self.embedding_dim = embedding_dim\n",
    "    self.n_hidden = n_hidden\n",
    "    self.n_classes = n_classes\n",
    "\n",
    "    self.attention = Attention(self.embedding_dim, self.n_hidden)\n",
    "    self.grucell = nn.GRUCell(self.embedding_dim, self.n_hidden)\n",
    "    self.fc = nn.Sequential(\n",
    "        nn.Linear(self.n_hidden, self.n_hidden),\n",
    "        nn.ReLU(),\n",
    "        nn.Linear(self.n_hidden, self.n_classes),\n",
    "        nn.Softmax(dim=1)\n",
    "    )\n",
    "  \n",
    "  def forward(self, X):\n",
    "    '''\n",
    "      x = batch_size * frames * embedding_dim\n",
    "\n",
    "    '''\n",
    "    h = torch.zeros(X.shape[0], self.n_hidden).to(device)\n",
    "    for i in range(X.shape[1]):\n",
    "      X[:,i,:] = self.attention(X[:,i,:].clone(),h)\n",
    "      h = self.grucell(X[:,i,:].clone(), h)\n",
    "\n",
    "    return self.fc(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vanilla_GRU(nn.Module):\n",
    "    def __init__(self, embedding_dim, n_hidden, n_classes=None):\n",
    "        super().__init__()\n",
    "\n",
    "        assert n_classes is not None\n",
    "        self.embedding_dim = embedding_dim\n",
    "        self.n_hidden = n_hidden\n",
    "        self.n_classes = n_classes\n",
    "\n",
    "        self.grucell = nn.GRUCell(self.embedding_dim, self.n_hidden)\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(self.n_hidden, self.n_hidden),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(self.n_hidden, self.n_classes),\n",
    "            nn.Softmax(dim=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, X):\n",
    "        h = torch.zeros(X.shape[0], self.n_hidden).to(device)\n",
    "        for i in range(X.shape[1]):\n",
    "            h = self.grucell(X[:, i, :].clone(), h)\n",
    "\n",
    "        return self.fc(h)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = EleAttG_GRU(2048, 256, 21).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "742"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, dataloader, device, n_epochs=10):\n",
    "    optimizer = torch.optim.AdamW(model.parameters())\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "    for epoch in range(n_epochs):\n",
    "        loss_val = 0\n",
    "        for i, (X, y) in enumerate(tqdm(dataloader)):\n",
    "            optimizer.zero_grad()\n",
    "            X = X.to(device)\n",
    "            y = y.to(device)\n",
    "            y_pred = model(X)\n",
    "            loss = criterion(y_pred, y)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            loss_val += loss.item()\n",
    "\n",
    "        print(f'Epoch:{epoch} Loss:{loss_val}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:05<00:00, 18.06it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:0 Loss:279.4576036930084\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:02<00:00, 36.84it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:1 Loss:269.66622257232666\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:02<00:00, 36.61it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:2 Loss:260.90824270248413\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:02<00:00, 35.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:3 Loss:255.88703393936157\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:02<00:00, 36.55it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:4 Loss:251.15085101127625\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:02<00:00, 38.64it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:5 Loss:248.5549385547638\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:02<00:00, 37.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:6 Loss:245.53940176963806\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:02<00:00, 38.11it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:7 Loss:244.5276312828064\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:02<00:00, 34.83it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:8 Loss:244.15678644180298\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:02<00:00, 34.69it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:9 Loss:241.0770275592804\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "train(model, training_loader, device, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vanilla_GRU(\n",
       "  (grucell): GRUCell(2048, 256)\n",
       "  (fc): Sequential(\n",
       "    (0): Linear(in_features=256, out_features=256, bias=True)\n",
       "    (1): ReLU()\n",
       "    (2): Linear(in_features=256, out_features=21, bias=True)\n",
       "    (3): Softmax(dim=1)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vanilla_model = Vanilla_GRU(2048, 256, 21)\n",
    "vanilla_model.to(device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:01<00:00, 77.55it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:0 Loss:281.9031364917755\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:01<00:00, 89.49it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:1 Loss:274.3010997772217\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:01<00:00, 82.94it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:2 Loss:267.6934576034546\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:01<00:00, 77.02it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:3 Loss:263.60641407966614\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:00<00:00, 96.06it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:4 Loss:256.8326573371887\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:01<00:00, 73.01it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:5 Loss:255.3929488658905\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:01<00:00, 87.52it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:6 Loss:249.226633310318\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:01<00:00, 72.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:7 Loss:246.36032056808472\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:01<00:00, 74.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:8 Loss:244.90765810012817\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 93/93 [00:01<00:00, 79.91it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:9 Loss:242.71159148216248\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "train(vanilla_model, training_loader, device, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 186/186 [00:01<00:00, 142.36it/s]\n"
     ]
    }
   ],
   "source": [
    "preds = list()\n",
    "y_true = list()\n",
    "\n",
    "for (X, y) in tqdm(test_dataset):\n",
    "    X = X.unsqueeze(0).to(device)\n",
    "    out = model(X).squeeze(0)\n",
    "    y_pred = out.argmax()\n",
    "    preds.append(y_pred.item())\n",
    "    y_true.append(y.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score, f1_score, classification_report, precision_score\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.00      0.00      0.00        10\n",
      "           1       0.58      1.00      0.73        11\n",
      "           2       0.00      0.00      0.00         9\n",
      "           3       0.50      1.00      0.67         5\n",
      "           4       0.26      0.78      0.39         9\n",
      "           5       1.00      1.00      1.00        14\n",
      "           6       0.19      0.43      0.26         7\n",
      "           7       0.67      0.93      0.78        15\n",
      "           8       0.00      0.00      0.00         9\n",
      "           9       0.80      0.89      0.84         9\n",
      "          10       0.29      1.00      0.45         7\n",
      "          11       0.00      0.00      0.00         8\n",
      "          12       1.00      0.87      0.93        15\n",
      "          13       0.00      0.00      0.00         6\n",
      "          14       0.00      0.00      0.00         8\n",
      "          15       0.00      0.00      0.00         8\n",
      "          16       0.00      0.00      0.00         4\n",
      "          17       1.00      0.67      0.80         9\n",
      "          18       0.58      0.78      0.67         9\n",
      "          19       0.00      0.00      0.00         8\n",
      "          20       0.27      0.50      0.35         6\n",
      "\n",
      "    accuracy                           0.53       186\n",
      "   macro avg       0.34      0.47      0.37       186\n",
      "weighted avg       0.41      0.53      0.44       186\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home2/dhruv.kapur/anaconda3/envs/pytorch/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/home2/dhruv.kapur/anaconda3/envs/pytorch/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/home2/dhruv.kapur/anaconda3/envs/pytorch/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "att_gru_accu = accuracy_score(y_true, preds)\n",
    "print(classification_report(y_true, preds))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 186/186 [00:00<00:00, 386.39it/s]\n"
     ]
    }
   ],
   "source": [
    "preds = list()\n",
    "y_true = list()\n",
    "\n",
    "for (X, y) in tqdm(test_dataset):\n",
    "    X = X.unsqueeze(0).to(device)\n",
    "    out = vanilla_model(X).squeeze(0)\n",
    "    y_pred = out.argmax()\n",
    "    preds.append(y_pred.item())\n",
    "    y_true.append(y.item())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.00      0.00      0.00        10\n",
      "           1       0.82      0.82      0.82        11\n",
      "           2       0.00      0.00      0.00         9\n",
      "           3       0.45      1.00      0.62         5\n",
      "           4       0.53      0.89      0.67         9\n",
      "           5       1.00      0.86      0.92        14\n",
      "           6       0.00      0.00      0.00         7\n",
      "           7       0.93      0.87      0.90        15\n",
      "           8       0.00      0.00      0.00         9\n",
      "           9       0.33      0.33      0.33         9\n",
      "          10       0.00      0.00      0.00         7\n",
      "          11       0.00      0.00      0.00         8\n",
      "          12       0.78      0.93      0.85        15\n",
      "          13       0.00      0.00      0.00         6\n",
      "          14       0.75      0.75      0.75         8\n",
      "          15       0.00      0.00      0.00         8\n",
      "          16       0.25      0.75      0.38         4\n",
      "          17       0.60      1.00      0.75         9\n",
      "          18       0.29      0.78      0.42         9\n",
      "          19       0.16      0.75      0.27         8\n",
      "          20       0.00      0.00      0.00         6\n",
      "\n",
      "    accuracy                           0.51       186\n",
      "   macro avg       0.33      0.46      0.37       186\n",
      "weighted avg       0.40      0.51      0.43       186\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home2/dhruv.kapur/anaconda3/envs/pytorch/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/home2/dhruv.kapur/anaconda3/envs/pytorch/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/home2/dhruv.kapur/anaconda3/envs/pytorch/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1318: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "vanilla_accu = accuracy_score(y_true, preds)\n",
    "print(classification_report(y_true, preds))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.510752688172043\n",
      "0.5268817204301075\n"
     ]
    }
   ],
   "source": [
    "print(vanilla_accu)\n",
    "print(att_gru_accu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "with open('train_dataset_jhmdb.pkl', 'wb') as f:\n",
    "    pickle.dump(train_dataset, f)\n",
    "\n",
    "with open('test_dataset_jhmdb.pkl', 'wb') as f:\n",
    "    pickle.dump(test_dataset, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "f54ec556731191ae34ffecbd12704bb8f2e6a5cabce98c16cdcccd50acdfe5bc"
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 ('base')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}