Face Recognition Using Desicion Tree .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "001eb483",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyodbc\n",
    "import matplotlib.pyplot as plt\n",
    "import io\n",
    "import os\n",
    "from PIL import Image\n",
    "from numpy import asarray\n",
    "import numpy as np\n",
    "import cv2\n",
    "from mtcnn.mtcnn import MTCNN\n",
    "from numpy import expand_dims\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from tkinter import *\n",
    "from tkinter import filedialog\n",
    "import imageio\n",
    "from PIL import ImageTk,Image\n",
    "import tkinter.font as font\n",
    "from playsound import playsound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f979d71c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nconn = pyodbc.connect( \\'Trusted_Connection=yes\\', Driver = \"{SQL Server Native Client 11.0};\" , Server= \\'DESKTOP-E7I8FQH\\' , Database= \\'Pictures\\')\\n \\n \\n \\nd = \"D:\\\\FCAIH Material\\\\Subjects Third Year\\\\First Term\\\\Artificial Intelligence\\\\Project\\\\images\"\\ni=0\\nx=0\\ny=0\\nfor path in os.listdir(d):\\n    if y==50:\\n        i=0\\n        x=0\\n    elif y > 50:\\n        if x == 5:\\n            i += 1\\n            x =0\\n    elif x==10:\\n        i += 1\\n        x = 0\\n    \\n    full_path = os.path.join(d, path)\\n    if os.path.isfile(full_path):\\n        cursor = conn.cursor()\\n        cursor.execute(\"insert into ImageTable (Class, image) values (\"+str(i)+\", (SELECT BulkColumn FROM Openrowset( Bulk \\'\"+full_path+\"\\', Single_Blob) as img))\")\\n        cursor.commit()\\n    x +=1\\n    y +=1\\n\\n'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    " \n",
    " \n",
    "'''\n",
    "conn = pyodbc.connect( 'Trusted_Connection=yes', Driver = \"{SQL Server Native Client 11.0};\" , Server= 'DESKTOP-E7I8FQH' , Database= 'Pictures')\n",
    " \n",
    " \n",
    " \n",
    "d = \"D:\\FCAIH Material\\Subjects Third Year\\First Term\\Artificial Intelligence\\Project\\Project 20 Code\\images\"\n",
    "i=0\n",
    "x=0\n",
    "y=0\n",
    "for path in os.listdir(d):\n",
    "    if y==50:\n",
    "        i=0\n",
    "        x=0\n",
    "    elif y > 50:\n",
    "        if x == 5:\n",
    "            i += 1\n",
    "            x =0\n",
    "    elif x==10:\n",
    "        i += 1\n",
    "        x = 0\n",
    "    \n",
    "    full_path = os.path.join(d, path)\n",
    "    if os.path.isfile(full_path):\n",
    "        cursor = conn.cursor()\n",
    "        cursor.execute(\"insert into ImageTable (Class, image) values (\"+str(i)+\", (SELECT BulkColumn FROM Openrowset( Bulk '\"+full_path+\"', Single_Blob) as img))\")\n",
    "        cursor.commit()\n",
    "    x +=1\n",
    "    y +=1\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3fcbcb3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#demonstate face detection on 5 Celebrity Faces Dataset\n",
    "# extract a single face from a given photograph\n",
    "def extract_face(filename, required_size=(100,100)):\n",
    "    # load image from file\n",
    "    image = filename\n",
    "    # convert to RGB, if needed\n",
    "    image = image.convert('RGB')\n",
    "    # convert to array\n",
    "    pixels = asarray(image)\n",
    "    # create the detector, using default weights\n",
    "    detector = MTCNN()\n",
    "    # detect faces in the image\n",
    "    results = detector.detect_faces(pixels)\n",
    "    # extract the bounding box from the first face\n",
    "    x1, y1, width, height = results[0]['box']\n",
    "    # bug fix\n",
    "    x1, y1 = abs(x1), abs(y1)\n",
    "    x2, y2 = x1 + width, y1 + height\n",
    "    # extract the face\n",
    "    face = pixels[y1:y2, x1:x2]\n",
    "    # resize pixels to the model size\n",
    "    image = Image.fromarray(face)\n",
    "    image = image.resize(required_size)\n",
    "    face_array = asarray(image)\n",
    "    # scale pixel values\n",
    "    face_pixels = face_array.astype('float32')\n",
    "    # standardize pixel values across channels (global)\n",
    "    face_pixels = (face_pixels - np.min(face_pixels)) / (np.max(face_pixels) - np.min(face_pixels))\n",
    "    face_pixels = cv2.cvtColor(face_pixels, cv2.COLOR_BGR2GRAY)\n",
    "    # transform face into one sample\n",
    "    samples = expand_dims(face_pixels, axis=0)\n",
    "    samples=samples.flatten()\n",
    "    return samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e70bc993",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 14 calls to <function Model.make_predict_function.<locals>.predict_function at 0x000002235D03B160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "WARNING:tensorflow:6 out of the last 15 calls to <function Model.make_predict_function.<locals>.predict_function at 0x000002235D03B160> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
     ]
    }
   ],
   "source": [
    "id=[]\n",
    "images=[]\n",
    "X_train=[]\n",
    "y_train=[]\n",
    "X_test=[]\n",
    "y_test=[]\n",
    "\n",
    "conn = pyodbc.connect( 'Trusted_Connection=yes', Driver = \"{SQL Server Native Client 11.0};\" , Server= 'DESKTOP-E7I8FQH' , Database= 'Pictures')\n",
    "\n",
    "\n",
    "\n",
    "global img\n",
    "\n",
    "cursor = conn.cursor()\n",
    "\n",
    "cursor.execute(\"select * from ImageTable\")\n",
    "\n",
    "for row in cursor:\n",
    "    id.append(row[1])\n",
    "    images.append(row[2])\n",
    "\n",
    "for i in range (0,50):\n",
    "    image = Image.open(io.BytesIO(images[i]))\n",
    "    face=extract_face(image).reshape(1,-1)\n",
    "    X_train.append(face)\n",
    "    y_train.append(id[i])\n",
    "    \n",
    "for i in range (50,len(images)):\n",
    "    image = Image.open(io.BytesIO(images[i]))\n",
    "    face=extract_face(image).reshape(1,-1)\n",
    "    X_test.append(face)\n",
    "    y_test.append(id[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "033431ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = np.asarray(X_train)\n",
    "X_train=X_train.reshape(X_train.shape[0],X_train.shape[1]*X_train.shape[2])\n",
    "y_train = np.asarray(y_train)\n",
    "X_test = np.asarray(X_test)\n",
    "X_test=X_test.reshape(X_test.shape[0],X_test.shape[1]*X_test.shape[2])\n",
    "y_test = np.asarray(y_test)\n",
    "#print(X_train.shape)\n",
    "#print(X_test.shape)\n",
    "#print(y_train.shape)\n",
    "#print(y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2b9db883",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DecisionTreeClassifierModel Train Score is :  100.0\n",
      "DecisionTreeClassifierModel Test Score is :  68.0\n"
     ]
    }
   ],
   "source": [
    "DecisionTreeClassifierModel = DecisionTreeClassifier(criterion='gini',max_depth=20,random_state=30)\n",
    "DecisionTreeClassifierModel.fit(X_train, y_train)\n",
    "print('DecisionTreeClassifierModel Train Score is : ' , DecisionTreeClassifierModel.score(X_train, y_train)*100)\n",
    "print('DecisionTreeClassifierModel Test Score is : ' , DecisionTreeClassifierModel.score(X_test, y_test)*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e28cdd72",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d5b9be8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "root = Tk()\n",
    "bg = ImageTk.PhotoImage(file=\"ground.jpg\")\n",
    "canvas = Canvas(root,width= 400, height= 300)\n",
    "canvas.pack(fill= \"both\", expand=True)\n",
    "canvas.create_image(0, 0, image=bg, anchor=\"nw\")\n",
    "root.title(\"Face Recognition Using Desicion Tree\")\n",
    "root.geometry(\"1000x702\")\n",
    "myFont1 = font.Font(family=\"Helvetica\",size=12,weight=\"bold\")\n",
    "myFont2 = font.Font(family=\"Helvetica\",size=18,weight=\"bold\")\n",
    "\n",
    "def browseImages():\n",
    "    filename = filedialog.askopenfilename(initialdir = \"/\", title = \"Select an Image\",\n",
    "                                          filetypes = ((\"jpg\",\"*.jpg*\"),\n",
    "                                                       (\"png\",\"*.png*\"),\n",
    "                                                       (\"jpeg\",\"*.jpeg*\"),\n",
    "                                                       (\"jfif\",\"*.jfif*\"),\n",
    "                                                        )\n",
    "                                         )\n",
    "    global imag\n",
    "    imag=Image.open(filename)\n",
    "    img=ImageTk.PhotoImage(Image.open(filename).resize((350,350)))\n",
    "    global label\n",
    "    label = Label(root, padx=200 ,pady=150)\n",
    "    label.place(relx = 0.5, rely = 0.42, anchor = 'center')\n",
    "    label.configure(image=img)\n",
    "    label.image = img\n",
    "\n",
    "    \n",
    "def classify_image(img):\n",
    "    var = StringVar()\n",
    "    face=extract_face(img).reshape(1,-1)\n",
    "    y_pred = DecisionTreeClassifierModel.predict(face)\n",
    "    global label3\n",
    "    if(y_pred==0):\n",
    "            label3 = Label(root,text=\"Mohamed Salah\" , fg = \"Black\", padx=1000 ,pady=28,font=myFont2)\n",
    "            label3.place(relx = 0.5, rely = 0.05,anchor='center')\n",
    "            playsound(\"D:\\FCAIH Material\\Subjects Third Year\\First Term\\Artificial Intelligence\\Project\\project ai\\sounds\\Mo Salah, The Egyptian King! _ Learn LFC Songs (mp3cut.net).mp3\")\n",
    "    if(y_pred==1):\n",
    "            label3 = Label(root,text=\"Lionel Messi\" , fg = \"Black\", padx=1000 ,pady=28,font=myFont2)\n",
    "            label3.place(relx = 0.5, rely = 0.05,anchor='center')\n",
    "            playsound(\"D:\\FCAIH Material\\Subjects Third Year\\First Term\\Artificial Intelligence\\Project\\project ai\\sounds\\messi.mp3\")\n",
    "    if(y_pred==2):\n",
    "            label3 = Label(root,text=\"Will Smith\" , fg = \"Black\", padx=1000 ,pady=28,font=myFont2)\n",
    "            label3.place(relx = 0.5, rely = 0.05,anchor='center')\n",
    "            playsound(\"D:\\FCAIH Material\\Subjects Third Year\\First Term\\Artificial Intelligence\\Project\\project ai\\sounds\\mp3-output-ttsfree(dot)comwill.mp3\")\n",
    "    if(y_pred==3):\n",
    "            label3 = Label(root,text=\"Cristiano Ronaldo\" , fg = \"Black\", padx=1000 ,pady=28,font=myFont2)\n",
    "            label3.place(relx = 0.5, rely = 0.05,anchor='center')\n",
    "            playsound(\"D:\\FCAIH Material\\Subjects Third Year\\First Term\\Artificial Intelligence\\Project\\project ai\\sounds\\Siuuu Sound Effect #2.mp3\")\n",
    "    if(y_pred==4):\n",
    "            label3 = Label(root,text=\"Angelina Jolie\" , fg = \"Black\", padx=1000 ,pady=28,font=myFont2)\n",
    "            label3.place(relx = 0.5, rely = 0.05,anchor='center')\n",
    "            playsound(\"D:\\FCAIH Material\\Subjects Third Year\\First Term\\Artificial Intelligence\\Project\\project ai\\sounds\\mp3-output-ttsfree(dot)com.mp3\")\n",
    "\n",
    "\n",
    "def clear_label_image():\n",
    "    label.destroy()\n",
    "    label3.destroy()\n",
    "    \n",
    "\n",
    "    \n",
    "def reco():\n",
    "        classify_image(imag)\n",
    "        \n",
    "\n",
    "\n",
    "imageButton = Button(root, text=\"Browse Image\", padx=20 ,pady=5, command=browseImages, fg=\"white\",bg=\"#533535\",font=myFont1,border=0)\n",
    "imageButton.place(relx = 0.2, rely = 0.84, anchor = 'center')\n",
    "\n",
    "recognizeButton = Button(root, text=\"Recognize !\", padx=20 ,pady=5, command=reco,fg=\"white\",bg=\"#064635\",font=myFont1,border=0)\n",
    "recognizeButton.place(relx = 0.51, rely = 0.88, anchor = 'center')\n",
    "\n",
    "clearButton = Button(root, text=\"Clear image\", padx=20 ,pady=5, command=clear_label_image,fg=\"white\",bg=\"#533535\",font=myFont1,border=0)\n",
    "clearButton.place(relx = 0.8, rely = 0.84, anchor = 'center')\n",
    "\n",
    "\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "47cd1db9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 10))\n",
    "ax.set_title('Decision Tree Testing Performance');\n",
    "plt.rcParams.update({'font.size': 15})\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "plot_confusion_matrix(DecisionTreeClassifierModel, X_test, y_test,ax=ax,cmap=plt.cm.Blues) \n",
    "plt.savefig('Decision Tree Testing Performance.png')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 10))\n",
    "ax.set_title('Decision Tree Training Performance');\n",
    "plt.rcParams.update({'font.size': 15})\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "plot_confusion_matrix(DecisionTreeClassifierModel, X_train, y_train,ax=ax,cmap=plt.cm.Reds) \n",
    "plt.savefig('Decision Tree Training Performance.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0eb8d95a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "387791d4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}