hog+CNN_based_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import copy\n",
    "import time\n",
    "import random\n",
    "import struct\n",
    "import torch\n",
    "import shutil\n",
    "from torchvision import transforms,datasets\n",
    "import torch.optim as optim\n",
    "from torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision\n",
    "import PIL\n",
    "from skimage.feature import hog\n",
    "from PIL import Image,ImageDraw\n",
    "from tqdm import tqdm\n",
    "from torch.utils.data import DataLoader\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "import torch.backends.cudnn as cudnn\n",
    "import pycm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.backends.cudnn.deterministic = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def copy_files(src_path,dest_path):\n",
    "    files=os.listdir(src_path)\n",
    "    while True:\n",
    "        if len(os.listdir(dest_path))>=412:\n",
    "            break\n",
    "        i=random.randint(0,len(os.listdir(src_path))-1)\n",
    "        img_file=files[i]\n",
    "        img_path=os.path.join(src_path,img_file)\n",
    "        img=cv2.imread(img_path)\n",
    "        img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)\n",
    "        img=Image.fromarray(img)\n",
    "        frame_draw=img.copy()\n",
    "        frame=img.resize((100,100), Image.BILINEAR)\n",
    "        img_dest_path=os.path.join(dest_path,img_file)\n",
    "        frame.save(img_dest_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_hot_embedding(labels, num_classes):\n",
    "    \"\"\"Embedding labels to one-hot form.\n",
    "\n",
    "    Args:\n",
    "      labels: (LongTensor) class labels, sized [N,].\n",
    "      num_classes: (int) number of classes.\n",
    "\n",
    "    Returns:\n",
    "      (tensor) encoded labels, sized [N, #classes].\n",
    "    \"\"\"\n",
    "    y = torch.eye(num_classes) \n",
    "    return y[labels] \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Extract_HOG_fd(torch_Tensor):\n",
    "    torch_Tensor=torch_Tensor.reshape(100,100,3)\n",
    "    img=np.asarray(torch_Tensor)\n",
    "    fd=hog(img, orientations=9, pixels_per_cell=(8, 8), \n",
    "                    cells_per_block=(2, 2), multichannel=True)\n",
    "    fd=fd.reshape(3,44,33)\n",
    "    fd=torch.from_numpy(fd)\n",
    "    return fd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "accu=[]\n",
    "for k in range(10): \n",
    "    i=random.randint(1,1000)\n",
    "    path1=r'C:\\Users\\occisor\\Downloads\\Engagement_recognition\\wacv2016-master\\1'\n",
    "    path2=r'C:\\Users\\occisor\\Downloads\\Engagement_recognition\\wacv2016-master\\2'\n",
    "    path3=r'C:\\Users\\occisor\\Downloads\\Engagement_recognition\\wacv2016-master\\3'\n",
    "    dest_path1=r'C:\\Users\\occisor\\Downloads\\Engagement_recognition\\wacv2016-master\\dataset\\1'\n",
    "    dest_path2=r'C:\\Users\\occisor\\Downloads\\Engagement_recognition\\wacv2016-master\\dataset\\2'\n",
    "    dest_path3=r'C:\\Users\\occisor\\Downloads\\Engagement_recognition\\wacv2016-master\\dataset\\3'\n",
    "\n",
    "    copy_files(path1,dest_path1)\n",
    "    copy_files(path2,dest_path2)\n",
    "    copy_files(path3,dest_path3)\n",
    "    \n",
    "    path=r'C:\\Users\\occisor\\Downloads\\Engagement_recognition\\wacv2016-master\\dataset'\n",
    "    \n",
    "    data_transforms = {\n",
    "        'train': transforms.Compose([\n",
    "            transforms.RandomHorizontalFlip(),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "        ])\n",
    "    }\n",
    "    image_datasets =datasets.ImageFolder(path,data_transforms['train'])\n",
    "    \n",
    "    dataset=[0 for i in range(len(image_datasets))]\n",
    "    for i in range(len(image_datasets)):\n",
    "        torch_Tensor=image_datasets[i][0]\n",
    "        fd=Extract_HOG_fd(torch_Tensor)\n",
    "        labels=image_datasets[i][1]\n",
    "        dataset[i]=(fd,labels)\n",
    "        \n",
    "    batch_size = 1\n",
    "    validation_split = .2\n",
    "    shuffle_dataset = True\n",
    "    random_seed= i\n",
    "\n",
    "    # Creating data indices for training and validation splits:\n",
    "    dataset_size = len(dataset)\n",
    "    indices = list(range(dataset_size))\n",
    "    split = int(np.floor(validation_split * dataset_size))\n",
    "    if shuffle_dataset :\n",
    "        np.random.seed(i)\n",
    "        np.random.shuffle(indices)\n",
    "    train_indices, val_indices = indices[split:], indices[:split]\n",
    "\n",
    "    # Creating PT data samplers and loaders:\n",
    "    train_sampler = SubsetRandomSampler(train_indices)\n",
    "    valid_sampler = SubsetRandomSampler(val_indices)\n",
    "\n",
    "    train_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, \n",
    "                                               sampler=train_sampler)\n",
    "    validation_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size,\n",
    "                                                    sampler=valid_sampler)\n",
    "\n",
    "    class LeNet(nn.Module):\n",
    "        def __init__(self):\n",
    "            super(LeNet, self).__init__()\n",
    "            self.conv1 = nn.Conv2d(3, 6, kernel_size=3,padding=2)\n",
    "            self.pool1 = nn.MaxPool2d(kernel_size=2,stride=2)\n",
    "            self.conv2 = nn.Conv2d(6, 9, kernel_size=3,padding=2)  \n",
    "            self.pool2 = nn.MaxPool2d(kernel_size=2,stride=2)\n",
    "            self.conv3 = nn.Conv2d(9,12, kernel_size=3,padding=2)\n",
    "            self.pool3 = nn.MaxPool2d(kernel_size=2,stride=2)\n",
    "            self.fc1 = nn.Linear(420,3)\n",
    "            \n",
    "\n",
    "        def forward(self, x):\n",
    "            x=F.relu(self.conv1(x))\n",
    "            x=self.pool1(x)\n",
    "            x=F.relu(self.conv2(x))\n",
    "            x=self.pool2(x)\n",
    "            x=F.relu(self.conv3(x))\n",
    "            x=self.pool3(x)\n",
    "            x=x.view((-1,420))\n",
    "            x=F.relu(self.fc1(x))\n",
    "            x=F.softmax(x)\n",
    "            return x\n",
    "\n",
    "    net=LeNet()\n",
    "    net=net.double()\n",
    "    net=net.cuda()\n",
    "\n",
    "\n",
    "    InputData=Variable(torch.Tensor(1,3,44,33))\n",
    "    InputData=InputData.double()\n",
    "    InputData=InputData.cuda()\n",
    "    output=net(InputData)\n",
    "\n",
    "    criterion=nn.MSELoss() \n",
    "    optimizer = optim.Adam(net.parameters(), lr=1e-4) # Adam\n",
    "\n",
    "    \n",
    "    for epoch in tqdm(range(5)):\n",
    "        for data in train_loader:\n",
    "            inputs,labels=data\n",
    "            inputs=inputs.double()\n",
    "            inputs=Variable(inputs.cuda())\n",
    "            labels=torch.LongTensor([labels])\n",
    "            labels=one_hot_embedding(labels,3)\n",
    "            labels=labels.reshape(1,3)\n",
    "            labels=labels.double()\n",
    "            labels=Variable(labels.cuda())\n",
    "            net.zero_grad()\n",
    "            output=net(inputs)\n",
    "            loss=criterion(labels,output)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "    count=0\n",
    "    net=net.eval()\n",
    "    y_label = []\n",
    "    y_pred = []\n",
    "    for data in validation_loader:\n",
    "        inputs,labels=data\n",
    "        inputs=inputs.double()\n",
    "        inputs=Variable(inputs.cuda())\n",
    "        labels=torch.LongTensor([labels])\n",
    "        labels=one_hot_embedding(labels,3)\n",
    "        labels=labels.reshape(1,3)\n",
    "        labels=labels.double()\n",
    "        labels=Variable(labels.cuda())\n",
    "        output=net(inputs)\n",
    "        y_pred.append(output.argmax())\n",
    "        y_label.append(labels.argmax())\n",
    "        print(output,end=\"\")\n",
    "        print(\"output's max arguement is {}\".format(output.argmax()),end=\" \")\n",
    "        print(\"labels max arguement is {}\".format(labels.argmax()))\n",
    "        if output.argmax()==labels.argmax():\n",
    "            count+=1\n",
    "        \n",
    "    ac=count/len(valid_sampler)\n",
    "    accu.append(ac)\n",
    "    shutil.rmtree(dest_path1) \n",
    "    shutil.rmtree(dest_path2)\n",
    "    os.mkdir(dest_path1)\n",
    "    os.mkdir(dest_path2)\n",
    "    torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "accu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = np.asarray(y_pred)\n",
    "y_pred = y_pred.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_label = np.asarray(y_label)\n",
    "y_label = y_label.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm = ConfusionMatrix(y_label, y_pred,digit=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm.ACC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm.GI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm.AGF"
   ]
  }
 ],
 "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}