4P1_Python project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pre-processing images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of images required for pre-processing1500\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                           | 0/29 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Preprocessing 1500 from each category...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████| 29/29 [03:11<00:00,  6.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DONE\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "USAGE:\n",
    "python preprocess_image.py --num-images 1200\n",
    "'''\n",
    "import os\n",
    "import cv2\n",
    "import random\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "num_images=int(input(\"Enter the number of images required for pre-processing\"))\n",
    "print(f\"Preprocessing {num_images} from each category...\")\n",
    "\n",
    "\n",
    "# get all the directory paths\n",
    "dir_paths = os.listdir('ASL\\\\input\\\\asl_alphabet_train\\\\asl_alphabet_train')\n",
    "dir_paths.sort()\n",
    "root_path = 'ASL\\\\input\\\\asl_alphabet_train\\\\asl_alphabet_train'\n",
    "\n",
    "\n",
    "# get --num-images images from each category\n",
    "for idx, dir_path  in tqdm(enumerate(dir_paths), total=len(dir_paths)):\n",
    "    all_images = os.listdir(f\"{root_path}/{dir_path}\")\n",
    "    os.makedirs(f\"ASL/input/preprocessed_image/{dir_path}\", exist_ok=True)\n",
    "    for i in range(num_images): # how many images to preprocess for each category\n",
    "        # generate a random id between 0 and 2999\n",
    "        rand_id = (random.randint(0, 2999))\n",
    "        image = cv2.imread(f\"{root_path}/{dir_path}/{all_images[rand_id]}\")\n",
    "        image = cv2.resize(image, (224, 224))\n",
    "        cv2.imwrite(f\"ASL/input/preprocessed_image/{dir_path}/{dir_path}{i}.jpg\", image)\n",
    "print('DONE')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a csv file with labels and path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 43500/43500 [02:01<00:00, 358.71it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first one hot encoded labels: [1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n",
      "Mapping the first one hot encoded label to its category: A\n",
      "Total instances: 43500\n",
      "Saving the binarized labels as pickled file\n",
      "                                 image_path  target\n",
      "0   ASL\\input\\preprocessed_image\\O\\O543.jpg    14.0\n",
      "1   ASL\\input\\preprocessed_image\\H\\H132.jpg     7.0\n",
      "2  ASL\\input\\preprocessed_image\\Z\\Z1451.jpg    25.0\n",
      "3  ASL\\input\\preprocessed_image\\K\\K1056.jpg    10.0\n",
      "4  ASL\\input\\preprocessed_image\\Z\\Z1353.jpg    25.0\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "USAGE:\n",
    "python create_csv.py\n",
    "'''\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import joblib\n",
    "from sklearn.preprocessing import LabelBinarizer\n",
    "from tqdm import tqdm\n",
    "from imutils import paths\n",
    "# get all the image paths\n",
    "image_paths = list(paths.list_images('ASL\\\\input\\\\preprocessed_image'))\n",
    "# create a DataFrame \n",
    "data = pd.DataFrame()\n",
    "labels = []\n",
    "for i, image_path in tqdm(enumerate(image_paths), total=len(image_paths)):\n",
    "    label = image_path.split(os.path.sep)[-2]\n",
    "    # save the relative path for mapping image to target\n",
    "    data.loc[i, 'image_path'] = image_path\n",
    "    labels.append(label)\n",
    "labels = np.array(labels)\n",
    "# one hot encode the labels\n",
    "lb = LabelBinarizer()\n",
    "labels = lb.fit_transform(labels)\n",
    "print(f\"The first one hot encoded labels: {labels[0]}\")\n",
    "print(f\"Mapping the first one hot encoded label to its category: {lb.classes_[0]}\")\n",
    "print(f\"Total instances: {len(labels)}\")\n",
    "for i in range(len(labels)):\n",
    "    index = np.argmax(labels[i])\n",
    "    data.loc[i, 'target'] = int(index)\n",
    "# shuffle the dataset\n",
    "data = data.sample(frac=1).reset_index(drop=True)\n",
    "# save as CSV file\n",
    "data.to_csv('ASL/input/data.csv', index=False)\n",
    "# pickle the binarized labels\n",
    "print('Saving the binarized labels as pickled file')\n",
    "joblib.dump(lb, 'ASL/output/lb.pkl')\n",
    "print(data.head(5))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cnn_models.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import joblib\n",
    "# load the binarized labels\n",
    "print('Loading label binarizer...')\n",
    "lb = joblib.load('C:\\\\Users\\\\SARAH\\\\Desktop\\\\Multivariate Stats\\\\ASL\\\\output\\\\lb.pkl')\n",
    "\n",
    "\n",
    "# ### creating neural network model\n",
    "\n",
    "\n",
    "\n",
    "class CustomCNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CustomCNN, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 16, 5)\n",
    "        self.conv2 = nn.Conv2d(16, 32, 5)\n",
    "        self.conv3 = nn.Conv2d(32, 64, 3)\n",
    "        self.conv4 = nn.Conv2d(64, 128, 5)\n",
    "        self.fc1 = nn.Linear(128, 256)\n",
    "        self.fc2 = nn.Linear(256, len(lb.classes_))\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "    def forward(self, x):\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        x = self.pool(F.relu(self.conv3(x)))\n",
    "        x = self.pool(F.relu(self.conv4(x)))\n",
    "        bs, _, _, _ = x.shape\n",
    "        x = F.adaptive_avg_pool2d(x, 1).reshape(bs, -1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training the CNN model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading label binarizer...\n",
      "Enter the number of epochs8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "  0%|                                                                                         | 0/1155 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computation device: cpu\n",
      "Training on 36975 images\n",
      "Validationg on 6525 images\n",
      "CustomCNN(\n",
      "  (conv1): Conv2d(3, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv2): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (conv4): Conv2d(64, 128, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=128, out_features=256, bias=True)\n",
      "  (fc2): Linear(in_features=256, out_features=29, bias=True)\n",
      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      ")\n",
      "277,949 total parameters.\n",
      "277,949 training parameters.\n",
      "Epoch 1 of 8\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-9-c88712b1a157>:94: DeprecationWarning: an integer is required (got type numpy.float64).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.\n",
      "  return torch.tensor(image, dtype=torch.float), torch.tensor(label, dtype=torch.long)\n",
      "1156it [43:31,  2.26s/it]                                                                                              \n",
      "  0%|                                                                                          | 0/203 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0386, Train Acc: 61.52\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "204it [03:26,  1.01s/it]                                                                                               \n",
      "  0%|                                                                                         | 0/1155 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0083, Val Acc: 90.64\n",
      "Epoch 2 of 8\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1156it [43:05,  2.24s/it]                                                                                              \n",
      "  0%|                                                                                          | 0/203 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0048, Train Acc: 94.78\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "204it [03:01,  1.12it/s]                                                                                               \n",
      "  0%|                                                                                         | 0/1155 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0049, Val Acc: 94.08\n",
      "Epoch 3 of 8\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1156it [40:19,  2.09s/it]                                                                                              \n",
      "  0%|                                                                                          | 0/203 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0023, Train Acc: 97.61\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "204it [03:02,  1.12it/s]                                                                                               \n",
      "  0%|                                                                                         | 0/1155 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0046, Val Acc: 95.19\n",
      "Epoch 4 of 8\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1156it [41:39,  2.16s/it]                                                                                              \n",
      "  0%|                                                                                          | 0/203 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0017, Train Acc: 98.38\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "204it [03:08,  1.08it/s]                                                                                               \n",
      "  0%|                                                                                         | 0/1155 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0031, Val Acc: 97.16\n",
      "Epoch 5 of 8\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1156it [40:27,  2.10s/it]                                                                                              \n",
      "  0%|                                                                                          | 0/203 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0014, Train Acc: 98.72\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "204it [03:05,  1.10it/s]                                                                                               \n",
      "  0%|                                                                                         | 0/1155 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0006, Val Acc: 99.36\n",
      "Epoch 6 of 8\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1156it [35:21,  1.84s/it]                                                                                              \n",
      "  0%|                                                                                          | 0/203 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0012, Train Acc: 98.73\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "204it [03:06,  1.09it/s]                                                                                               \n",
      "  0%|                                                                                         | 0/1155 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0016, Val Acc: 98.30\n",
      "Epoch 7 of 8\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1156it [42:48,  2.22s/it]                                                                                              \n",
      "  0%|                                                                                          | 0/203 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0011, Train Acc: 98.99\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "204it [03:16,  1.04it/s]                                                                                               \n",
      "  0%|                                                                                         | 0/1155 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0009, Val Acc: 99.25\n",
      "Epoch 8 of 8\n",
      "Training\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1156it [43:47,  2.27s/it]                                                                                              \n",
      "  0%|                                                                                          | 0/203 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Loss: 0.0007, Train Acc: 99.39\n",
      "Validating\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "204it [03:28,  1.02s/it]                                                                                               \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Loss: 0.0011, Val Acc: 98.85\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving model...\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "USAGE:\n",
    "python train.py --epochs 10\n",
    "'''\n",
    "import pandas as pd\n",
    "import joblib\n",
    "import numpy as np\n",
    "import torch\n",
    "import random\n",
    "import albumentations\n",
    "import matplotlib.pyplot as plt\n",
    "import argparse\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchvision.transforms as transforms\n",
    "import time\n",
    "import cv2\n",
    "import cnn_models\n",
    "from tqdm import tqdm\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "# construct the argument parser and parse the arguments\n",
    "\n",
    "num_epoch=int(input(\"Enter the number of epochs\"))\n",
    "''' SEED Everything '''\n",
    "def seed_everything(SEED=42):\n",
    "    random.seed(SEED)\n",
    "    np.random.seed(SEED)\n",
    "    torch.manual_seed(SEED)\n",
    "    torch.cuda.manual_seed(SEED)\n",
    "    torch.cuda.manual_seed_all(SEED)\n",
    "    torch.backends.cudnn.benchmark = True \n",
    "SEED=42\n",
    "seed_everything(SEED=SEED)\n",
    "''' SEED Everything '''\n",
    "# set computation device\n",
    "device = ('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "print(f\"Computation device: {device}\")\n",
    "\n",
    "\n",
    "# ### Reading and preparing train and validation set\n",
    "# \n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "# read the data.csv file and get the image paths and labels\n",
    "df = pd.read_csv('ASL/input/data.csv')\n",
    "X = df.image_path.values\n",
    "y = df.target.values\n",
    "(xtrain, xtest, ytrain, ytest) = (train_test_split(X, y, \n",
    "                                test_size=0.15, random_state=42))\n",
    "print(f\"Training on {len(xtrain)} images\")\n",
    "print(f\"Validationg on {len(xtest)} images\")\n",
    "\n",
    "\n",
    "# ### custom dataset module\n",
    "# \n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "# image dataset module\n",
    "class ASLImageDataset(Dataset):\n",
    "    def __init__(self, path, labels):\n",
    "        self.X = path\n",
    "        self.y = labels\n",
    "        # apply augmentations\n",
    "        self.aug = albumentations.Compose([\n",
    "            albumentations.Resize(224, 224, always_apply=True),\n",
    "        ])\n",
    "    def __len__(self):\n",
    "        return (len(self.X))\n",
    "    \n",
    "    def __getitem__(self, i):\n",
    "        image = cv2.imread(self.X[i])\n",
    "        image = self.aug(image=np.array(image))['image']\n",
    "        image = np.transpose(image, (2, 0, 1)).astype(np.float32)\n",
    "        label = self.y[i]\n",
    "        return torch.tensor(image, dtype=torch.float), torch.tensor(label, dtype=torch.long)\n",
    "\n",
    "train_data = ASLImageDataset(xtrain, ytrain)\n",
    "test_data = ASLImageDataset(xtest, ytest)\n",
    " \n",
    "# dataloaders\n",
    "trainloader = DataLoader(train_data, batch_size=32, shuffle=True)\n",
    "testloader = DataLoader(test_data, batch_size=32, shuffle=False)\n",
    "\n",
    "\n",
    "# ### preparing our neural network\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "# model = models.MobineNetV2(pretrained=True, requires_grad=False)\n",
    "model = cnn_models.CustomCNN().to(device)\n",
    "print(model)\n",
    "# total parameters and trainable parameters\n",
    "total_params = sum(p.numel() for p in model.parameters())\n",
    "print(f\"{total_params:,} total parameters.\")\n",
    "total_trainable_params = sum(\n",
    "    p.numel() for p in model.parameters() if p.requires_grad)\n",
    "print(f\"{total_trainable_params:,} training parameters.\")\n",
    "\n",
    "\n",
    "# optimizer\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
    "# loss function\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "# training function\n",
    "def fit(model, dataloader):\n",
    "    print('Training')\n",
    "    model.train()\n",
    "    running_loss = 0.0\n",
    "    running_correct = 0\n",
    "    for i, data in tqdm(enumerate(dataloader), total=int(len(train_data)/dataloader.batch_size)):\n",
    "        data, target = data[0].to(device), data[1].to(device)\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(data)\n",
    "        loss = criterion(outputs, target)\n",
    "        running_loss += loss.item()\n",
    "        _, preds = torch.max(outputs.data, 1)\n",
    "        running_correct += (preds == target).sum().item()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    train_loss = running_loss/len(dataloader.dataset)\n",
    "    train_accuracy = 100. * running_correct/len(dataloader.dataset)\n",
    "    \n",
    "    print(f\"Train Loss: {train_loss:.4f}, Train Acc: {train_accuracy:.2f}\")\n",
    "    \n",
    "    return train_loss, train_accuracy\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#validation function\n",
    "def validate(model, dataloader):\n",
    "    print('Validating')\n",
    "    model.eval()\n",
    "    running_loss = 0.0\n",
    "    running_correct = 0\n",
    "    with torch.no_grad():\n",
    "        for i, data in tqdm(enumerate(dataloader), total=int(len(test_data)/dataloader.batch_size)):\n",
    "            data, target = data[0].to(device), data[1].to(device)\n",
    "            outputs = model(data)\n",
    "            loss = criterion(outputs, target)\n",
    "            \n",
    "            running_loss += loss.item()\n",
    "            _, preds = torch.max(outputs.data, 1)\n",
    "            running_correct += (preds == target).sum().item()\n",
    "        \n",
    "        val_loss = running_loss/len(dataloader.dataset)\n",
    "        val_accuracy = 100. * running_correct/len(dataloader.dataset)\n",
    "        print(f'Val Loss: {val_loss:.4f}, Val Acc: {val_accuracy:.2f}')\n",
    "        \n",
    "        return val_loss, val_accuracy\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "train_loss , train_accuracy = [], []\n",
    "val_loss , val_accuracy = [], []\n",
    "start = time.time()\n",
    "for epoch in range(num_epoch):\n",
    "    print(f\"Epoch {epoch+1} of {num_epoch}\")\n",
    "    train_epoch_loss, train_epoch_accuracy = fit(model, trainloader)\n",
    "    val_epoch_loss, val_epoch_accuracy = validate(model, testloader)\n",
    "    train_loss.append(train_epoch_loss)\n",
    "    train_accuracy.append(train_epoch_accuracy)\n",
    "    val_loss.append(val_epoch_loss)\n",
    "    val_accuracy.append(val_epoch_accuracy)\n",
    "end = time.time()\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "# accuracy plots\n",
    "plt.figure(figsize=(10, 7))\n",
    "plt.plot(train_accuracy, color='green', label='train accuracy')\n",
    "plt.plot(val_accuracy, color='blue', label='validataion accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "plt.savefig('ASL/output/accuracy.png')\n",
    "plt.show()\n",
    " \n",
    "# loss plots\n",
    "plt.figure(figsize=(10, 7))\n",
    "plt.plot(train_loss, color='orange', label='train loss')\n",
    "plt.plot(val_loss, color='red', label='validataion loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "plt.savefig('ASL/output/loss.png')\n",
    "plt.show()\n",
    "# save the model to disk\n",
    "print('Saving model...')\n",
    "torch.save(model.state_dict(), 'ASL/output/model.pth')\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing the CNN model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the path of test imageC:\\Users\\SARAH\\Desktop\\Multivariate Stats\\ASL\\input\\asl_alphabet_test\\asl_alphabet_test\\A_test.jpg\n",
      "CustomCNN(\n",
      "  (conv1): Conv2d(3, 16, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv2): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
      "  (conv4): Conv2d(64, 128, kernel_size=(5, 5), stride=(1, 1))\n",
      "  (fc1): Linear(in_features=128, out_features=256, bias=True)\n",
      "  (fc2): Linear(in_features=256, out_features=29, bias=True)\n",
      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      ")\n",
      "Model loaded\n",
      "torch.Size([1, 3, 224, 224])\n",
      "PREDS tensor([0])\n",
      "Predicted output: A\n",
      "0.046 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#!/usr/bin/env python\n",
    "# coding: utf-8\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "'''\n",
    "USAGE:\n",
    "python test.py --img A_test.jpg\n",
    "'''\n",
    "import torch\n",
    "import joblib\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import cv2\n",
    "import albumentations\n",
    "import torch.nn.functional as F\n",
    "import time\n",
    "import cnn_models\n",
    "# construct the argument parser and parse the arguments\n",
    "test_img=input(\"Enter the path of test image\")\n",
    "\n",
    "\n",
    "aug = albumentations.Compose([\n",
    "                albumentations.Resize(224, 224, always_apply=True),\n",
    "])\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "# load label binarizer\n",
    "lb = joblib.load('ASL/output/lb.pkl')\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "model = cnn_models.CustomCNN()\n",
    "model.load_state_dict(torch.load('ASL/output/model.pth'))\n",
    "print(model)\n",
    "print('Model loaded')\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "image = cv2.imread(test_img)\n",
    "image_copy = image.copy()\n",
    " \n",
    "image = aug(image=np.array(image))['image']\n",
    "image = np.transpose(image, (2, 0, 1)).astype(np.float32)\n",
    "image = torch.tensor(image, dtype=torch.float)\n",
    "image = image.unsqueeze(0)\n",
    "print(image.shape)\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "start = time.time()\n",
    "outputs = model(image)\n",
    "_, preds = torch.max(outputs.data, 1)\n",
    "print('PREDS', preds)\n",
    "print(f\"Predicted output: {lb.classes_[preds]}\")\n",
    "end = time.time()\n",
    "print(f\"{(end-start):.3f} seconds\")\n",
    " \n",
    "cv2.putText(image_copy, lb.classes_[preds], (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)\n",
    "\n",
    "plt.imshow(image_copy, cmap = 'gray', interpolation = 'bicubic')\n",
    "plt.xticks([]), plt.yticks([])  # to hide tick values on X and Y axis\n",
    "plt.show()\n",
    "#cv2.imshow('image', image_copy)\n",
    "#cv2.waitKey(0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Realtime.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python\n",
    "# coding: utf-8\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "'''\n",
    "USAGE:\n",
    "python cam_test.py \n",
    "'''\n",
    "import torch\n",
    "import joblib\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import cv2\n",
    "import torch.nn.functional as F\n",
    "import time\n",
    "import cnn_models\n",
    " \n",
    "# load label binarizer\n",
    "lb = joblib.load('ASL/output/lb.pkl')\n",
    "model = cnn_models.CustomCNN()\n",
    "model.load_state_dict(torch.load('ASL/output/model.pth'))\n",
    "print(model)\n",
    "print('Model loaded')\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "def hand_area(img):\n",
    "    hand = img[100:324, 100:324]\n",
    "    hand = cv2.resize(hand, (224,224))\n",
    "    return hand\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "cap = cv2.VideoCapture(0)\n",
    "if (cap.isOpened() == False):\n",
    "    print('Error while trying to open camera. Plese check again...')\n",
    "# get the frame width and height\n",
    "frame_width = int(cap.get(3))\n",
    "frame_height = int(cap.get(4))\n",
    "# define codec and create VideoWriter object\n",
    "out = cv2.VideoWriter('ASL/output/asl.mp4', cv2.VideoWriter_fourcc(*'mp4v'), 30, (frame_width,frame_height))\n",
    "\n",
    "\n",
    "# In[ ]:\n",
    "\n",
    "\n",
    "while(cap.isOpened()):\n",
    "    # capture each frame of the video\n",
    "    ret, frame = cap.read()\n",
    "    # get the hand area on the video capture screen\n",
    "    cv2.rectangle(frame, (100, 100), (324, 324), (20, 34, 255), 2)\n",
    "    hand = hand_area(frame)\n",
    "    image = hand\n",
    "    \n",
    "    image = np.transpose(image, (2, 0, 1)).astype(np.float32)\n",
    "    image = torch.tensor(image, dtype=torch.float)\n",
    "    image = image.unsqueeze(0)\n",
    "    \n",
    "    outputs = model(image)\n",
    "    _, preds = torch.max(outputs.data, 1)\n",
    "    \n",
    "    cv2.putText(frame, lb.classes_[preds], (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)\n",
    "    cv2.imshow('image', frame)\n",
    "    out.write(frame)\n",
    "    # press `q` to exit\n",
    "    if cv2.waitKey(27) & 0xFF == ord('q'):\n",
    "        break\n",
    "# release VideoCapture()\n",
    "cap.release()\n",
    "# close all frames and video windows\n",
    "cv2.destroyAllWindows()\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}