testing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing Notebook\n",
    "\n",
    "This notebook is a tool to test the accuracy of the model using the validation dataset that has been created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import thrid party libraries\n",
    "\n",
    "import numpy as np\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "\n",
    "# Import the core library from Precencia\n",
    "\n",
    "from src.core.face_detector import FaceDetector\n",
    "from src.core.face_encoder import FaceEncoder\n",
    "from src.core.face_verificator import FaceVerificator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "face_detector = FaceDetector()\n",
    "face_encoder = FaceEncoder()\n",
    "face_recognizer = FaceVerificator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = os.listdir(os.getcwd() + '\\data\\\\testing')\n",
    "print(names)\n",
    "print(\"Length: {}\".format(len(names)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Jayaku_Briliantio\"\n",
    "\n",
    "extracted_face = face_detector.extract_face(image_path=os.getcwd() + '\\data\\\\testing\\\\{}\\\\{}_0001.jpg'.format(name, name))\n",
    "plt.imshow(extracted_face)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualize Testing Data Pair\n",
    "\n",
    "target_shape = (160, 160)\n",
    "\n",
    "def show(ax, image):\n",
    "    ax.imshow(face_detector.extract_face(image_path=os.getcwd() + image))\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(4, 10))\n",
    "\n",
    "axs = fig.subplots(5, 2)\n",
    "\n",
    "selected_names = ['Elon_Musk', 'Larry_Page', 'Linus_Torvalds', 'Mark_Zuckerberg', 'Sundar_Pichai']\n",
    "\n",
    "for i, name in enumerate(selected_names):\n",
    "    print(name)\n",
    "    show(axs[i, 0], '\\data\\\\testing\\\\{}\\\\{}_0001.jpg'.format(name, name))\n",
    "    show(axs[i, 1], '\\data\\\\testing\\\\{}\\\\{}_0003.jpg'.format(name, name))\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create anchor embeddings\n",
    "\n",
    "anchor_embeddings = []\n",
    "\n",
    "for name in names:\n",
    "  print(name)\n",
    "  paths = os.listdir(os.getcwd() + '\\data\\\\testing\\\\{}'.format(name))\n",
    "  path = os.getcwd() + '\\data\\\\testing\\\\{}\\\\'.format(name) + paths[0]\n",
    "  extracted_face = face_detector.extract_face(image_path=path)\n",
    "  anchor_embeddings.append(face_encoder.get_embedding(image_array=extracted_face))\n",
    "\n",
    "np.save('./data/encodings/testing_anchor_embeddings_n40.npy', anchor_embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Ma_HuaTeng\"\n",
    "\n",
    "images = os.listdir(os.getcwd() + '\\data\\\\testing\\\\{}'.format(name))\n",
    "input_person_embedding = []\n",
    "for idx, image in enumerate(images):\n",
    "  print(idx)\n",
    "  path = os.getcwd() + '\\data\\\\testing\\\\{}\\\\{}'.format(name, image)\n",
    "  extracted_face = face_detector.extract_face(image_path=path)\n",
    "  input_person_embedding.append(face_encoder.get_embedding(image_array=extracted_face))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create input embeddings\n",
    "\n",
    "input_embeddings = []\n",
    "\n",
    "for name in names:\n",
    "  print(name)\n",
    "  images = os.listdir(os.getcwd() + '\\data\\\\testing\\\\{}'.format(name))\n",
    "  images.pop(0) # Pop the anchor image\n",
    "  input_person_embedding = []\n",
    "  for image in images:\n",
    "    path = os.getcwd() + '\\data\\\\testing\\\\{}\\\\{}'.format(name, image)\n",
    "    extracted_face = face_detector.extract_face(image_path=path)\n",
    "    input_person_embedding.append(face_encoder.get_embedding(image_array=extracted_face))\n",
    "  \n",
    "  input_embeddings.append(input_person_embedding)\n",
    "\n",
    "np.save('./data/encodings/testing_input_embeddings_n40.npy', input_embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load testing anchor and input embeddings\n",
    "\n",
    "anchor_embeddings = np.load('./data/encodings/testing_anchor_embeddings_n40.npy')\n",
    "input_embeddings = np.load('./data/encodings/testing_input_embeddings_n40.npy')\n",
    "\n",
    "print(np.shape(anchor_embeddings))\n",
    "print(np.shape(input_embeddings))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_user(face_embedding):\n",
    "  similarities = [face_recognizer.compare(\n",
    "        face_embedding, anchor_embedding) for anchor_embedding in anchor_embeddings]\n",
    "  \n",
    "  max_similarity = max(similarities)\n",
    "  print(\"Maximum similarities: {}\".format(max_similarity))\n",
    "  max_similarity_index = similarities.index(max_similarity)\n",
    "\n",
    "  if max_similarity > 0.99:\n",
    "    user = names[max_similarity_index]\n",
    "    return user\n",
    "    \n",
    "  return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_predicted = []\n",
    "false_predicted = []\n",
    "not_predicted = []\n",
    "\n",
    "for idx, input_person_embedding in enumerate(input_embeddings):\n",
    "  current_user = names[idx]\n",
    "  true_predicted_user = 0\n",
    "  false_predicted_user = 0\n",
    "  not_predicted_user = 0\n",
    "  for face_embedding in input_person_embedding:\n",
    "    user = predict_user(face_embedding)\n",
    "    if user is not None:\n",
    "      print(\"Actual User: {}, Predicted User: {}\".format(current_user, user))\n",
    "      if user == current_user:\n",
    "        true_predicted_user += 1\n",
    "      else:\n",
    "        false_predicted_user += 1\n",
    "    else:\n",
    "      not_predicted_user += 1\n",
    "  \n",
    "  true_predicted.append(true_predicted_user)\n",
    "  false_predicted.append(false_predicted_user)\n",
    "  not_predicted.append(not_predicted_user)\n",
    "  print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(true_predicted)\n",
    "print(false_predicted)\n",
    "print(not_predicted)\n",
    "\n",
    "accuracy = np.sum(true_predicted) / (len(names) * 5)\n",
    "error_rate = np.sum(false_predicted) / (len(names) * 5)\n",
    "unidentified = np.sum(not_predicted) / (len(names) * 5)\n",
    "\n",
    "print(\"Accuracy: {}\".format(accuracy))\n",
    "print(\"Error Rate: {}\".format(error_rate))\n",
    "print(\"Unidentified: {}\".format(unidentified))"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "774e75caea246c4358f04e0613681c0f16b060685ad186b54b70e43cb49089fd"
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 64-bit ('env': venv)",
   "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.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}