FaceRecognition_Accuracy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import transforms, datasets\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch.nn as nn\n",
    "import cv2\n",
    "from facenet_pytorch import MTCNN, InceptionResnetV1\n",
    "from PIL import Image\n",
    "\n",
    "# The model is running on CPU, since it is already pre-trained and doesnt require GPU\n",
    "device = torch.device('cpu') \n",
    "print('Running on device: {}'.format(device))\n",
    "\n",
    "#Define MTCNN module\n",
    "#Since MTCNN is a collection of neural nets and other code, \n",
    "#The device must be passed in the following way to enable copying of objects when needed internally.\n",
    "mtcnn = MTCNN(\n",
    "    image_size=160, margin=0, min_face_size=20,\n",
    "    thresholds=[0.6, 0.7, 0.7], factor=0.709, prewhiten=True,\n",
    "    device=device\n",
    ")\n",
    "#Function takes 2 vectors 'a' and 'b'\n",
    "#Returns the cosine similarity according to the definition of the dot product\n",
    "def cos_sim(a, b):\n",
    "    dot_product = np.dot(a, b)\n",
    "    norm_a = np.linalg.norm(a)\n",
    "    norm_b = np.linalg.norm(b)\n",
    "    return dot_product / (norm_a * norm_b)\n",
    "\n",
    "#cos_sim returns real numbers,where negative numbers have different interpretations.\n",
    "#So we use this function to return only positive values.\n",
    "def cos(a,b):\n",
    "    minx = -1 \n",
    "    maxx = 1\n",
    "    return (cos_sim(a,b)- minx)/(maxx-minx)\n",
    "\n",
    "# Define Inception Resnet V1 module (GoogLe Net)\n",
    "resnet = InceptionResnetV1(pretrained='vggface2').eval().to(device)\n",
    "\n",
    "# Define a dataset and data loader\n",
    "dataset = datasets.ImageFolder('Film/Test')\n",
    "dataset.idx_to_class = {i:c for c, i in dataset.class_to_idx.items()}\n",
    "loader = DataLoader(dataset, collate_fn=lambda x: x[0])\n",
    "\n",
    "#Perfom MTCNN facial detection\n",
    "#Detects the face present in the image and prints the probablity of face detected in the image.\n",
    "aligned = []\n",
    "names = []\n",
    "for x, y in loader:\n",
    "    x_aligned, prob = mtcnn(x, return_prob=True)\n",
    "    if x_aligned is not None:\n",
    "        print('Face detected with probability: {:8f}'.format(prob))\n",
    "        aligned.append(x_aligned)\n",
    "        names.append(dataset.idx_to_class[y])\n",
    "\n",
    "# Calculate the 512 face embeddings\n",
    "aligned = torch.stack(aligned).to(device)\n",
    "embeddings = resnet(aligned).cpu()\n",
    "\n",
    "# Print distance matrix for classes.\n",
    "#The embeddings are plotted in space and cosine distace is measured.\n",
    "cos_sim = nn.CosineSimilarity(dim=-1, eps=1e-6)\n",
    "for i in range(0,len(names)):\n",
    "    emb=embeddings[i].unsqueeze(0)\n",
    "    # The cosine similarity between the embeddings is given by 'dist'.\n",
    "    dist =cos(embeddings[0],emb)  \n",
    "        \n",
    "dists = [[cos(e1,e2).item() for e2 in embeddings] for e1 in embeddings]\n",
    "# The print statement below is\n",
    "#Helpful for analysing the results and for determining the value of threshold.\n",
    "print(pd.DataFrame(dists, columns=names, index=names)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculating Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import random\n",
    "import numpy as np\n",
    "from facenet_pytorch import MTCNN, InceptionResnetV1,extract_face\n",
    "from PIL import Image,ImageDraw\n",
    "import torch\n",
    "import cv2\n",
    "import torch.nn as nn\n",
    "\n",
    "#Define list 'name' with the names of subjects in dataset.\n",
    "name= ['Deepika Padukone', 'Hritik Roshan', 'Mammootty', 'Mohanlal', 'Nazriya', 'Nivin Pauly', 'ShahRukh Khan', 'Shobana', 'Sridevi Kapoor', 'Varun Dhawan']  #names of the folders in ur prediction dataset\n",
    "\n",
    "#Model running on CPU\n",
    "device = torch.device('cpu')  \n",
    "\n",
    "#Define Inception V1 module (GoogLeNet)\n",
    "resnet = InceptionResnetV1(pretrained='vggface2').eval().to('cpu')\n",
    "\n",
    "#Define MTCNN module\n",
    "#Since MTCNN is a collection of neural nets and other code, \n",
    "#The device must be passed in the following way to enable copying of objects when needed internally.\n",
    "#'keep_all' is kept True. All the faces present in the image will be detected.\n",
    "mtcnn = MTCNN(\n",
    "    image_size=160, margin=0, min_face_size=20,\n",
    "    thresholds=[0.6, 0.7, 0.7], factor=0.709, prewhiten=True,\n",
    "    device=device,keep_all=True\n",
    ")\n",
    "\n",
    "#Function for performing face recognition\n",
    "def verify(embedding):\n",
    "    for i,k in enumerate(embeddings):\n",
    "        for j,l in enumerate(embedding):\n",
    "            #Cosine similarity distance is calculated.\n",
    "            dist =cos(k,l)\n",
    "            \n",
    "            #Chosen threshold is 0.81\n",
    "            #Threshold is determined after seeing the table in the previous cell.\n",
    "            #If the cosine distance is more than 0.85, name of that person is returned.\n",
    "            if dist > 0.81:\n",
    "                return names[i]\n",
    "            \n",
    "#Function to get file list and save it as prediction dataset.\n",
    "#Return prediction dataset.\n",
    "def get_files(nam): \n",
    "    files = glob.glob(\"Predict/%s/*\" %nam)\n",
    "    prediction = files[:int(len(files))] \n",
    "    return prediction\n",
    "\n",
    "#Function for storing and returning files and their corresponding labels in the prediction dataset.\n",
    "def make_sets():  \n",
    "    prediction_data = []\n",
    "    prediction_labels = []\n",
    "    \n",
    "    # The face is cropped from image after detecting face using MTCNN.\n",
    "    #prediction_data and prediction_labels are then updated.\n",
    "    for nam in name:\n",
    "        prediction = get_files(nam)\n",
    "        for item in prediction: \n",
    "            img = Image.open(item)\n",
    "            img_cropped = mtcnn(img)\n",
    "            prediction_data.append(img_cropped)\n",
    "            prediction_labels.append(nam)\n",
    "     \n",
    "    return prediction_data, prediction_labels\n",
    "\n",
    "#Function that prints incorrect match and returns the percentage accuracy \n",
    "def run_recognizer():\n",
    "    prediction_data, prediction_labels = make_sets()\n",
    "    print (\"Predicting classification set...\")\n",
    "    cnt = 0\n",
    "    correct = 0\n",
    "    incorrect = 0\n",
    "    none=0\n",
    "    for image in prediction_data:\n",
    "        im=resnet(image)\n",
    "        pred=verify(im)\n",
    "        #If the prediction matched with the testing images, correct variable is incremented\n",
    "        if pred == prediction_labels[cnt]:\n",
    "            correct += 1\n",
    "            cnt += 1\n",
    "        #else, the incorrect match is printed on screen\n",
    "        #incorrect varable is incremented.\n",
    "        else:\n",
    "            print(prediction_labels[cnt],' predicted as ',pred)\n",
    "            incorrect += 1\n",
    "            cnt += 1\n",
    "    #Returning the perentage of how many are predicted correctly.\n",
    "    return ((100*correct)/(correct + incorrect))\n",
    "\n",
    "metascore = []\n",
    "print(\"\\n\")\n",
    "for i in range(0,1):\n",
    "    correct = run_recognizer()\n",
    "    #metascore is updated, each time the loop runs\n",
    "    metascore.append(correct)\n",
    "    \n",
    "#Finally, the mean percentage is calcuted and printed on screen.\n",
    "print(\"\\nDataset accuracy: \", np.mean(metascore), \"% correct!!\")"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}