Add files using upload-large-folder tool

25. Face Recognition/.ipynb_checkpoints/25.0 Face Extraction from Video - Build Dataset-checkpoint.ipynb

@@ -0,0 +1,93 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Extracting the faces from a video"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from os import listdir\n",
+    "from os.path import isfile, join\n",
+    "import os\n",
+    "import cv2\n",
+    "import dlib\n",
+    "import numpy as np\n",
+    "\n",
+    "# Define Image Path Here\n",
+    "image_path = \"./images/\"\n",
+    "\n",
+    "def draw_label(image, point, label, font=cv2.FONT_HERSHEY_SIMPLEX,\n",
+    "               font_scale=0.8, thickness=1):\n",
+    "    size = cv2.getTextSize(label, font, font_scale, thickness)[0]\n",
+    "    x, y = point\n",
+    "    cv2.rectangle(image, (x, y - size[1]), (x + size[0], y), (255, 0, 0), cv2.FILLED)\n",
+    "    cv2.putText(image, label, point, font, font_scale, (255, 255, 255), thickness, lineType=cv2.LINE_AA)\n",
+    "    \n",
+    "detector = dlib.get_frontal_face_detector()\n",
+    "\n",
+    "# Initialize Webcam\n",
+    "cap = cv2.VideoCapture('testfriends.mp4')\n",
+    "img_size = 64\n",
+    "margin = 0.2\n",
+    "frame_count = 0\n",
+    "\n",
+    "while True:\n",
+    "    ret, frame = cap.read()\n",
+    "    frame_count += 1\n",
+    "    print(frame_count)   \n",
+    " \n",
+    "    input_img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
+    "    img_h, img_w, _ = np.shape(input_img)\n",
+    "    detected = detector(frame, 1)\n",
+    "    faces = []\n",
+    "    \n",
+    "    if len(detected) > 0:\n",
+    "        for i, d in enumerate(detected):\n",
+    "            x1, y1, x2, y2, w, h = d.left(), d.top(), d.right() + 1, d.bottom() + 1, d.width(), d.height()\n",
+    "            xw1 = max(int(x1 - margin * w), 0)\n",
+    "            yw1 = max(int(y1 - margin * h), 0)\n",
+    "            xw2 = min(int(x2 + margin * w), img_w - 1)\n",
+    "            yw2 = min(int(y2 + margin * h), img_h - 1)\n",
+    "            face =  frame[yw1:yw2 + 1, xw1:xw2 + 1, :]\n",
+    "            file_name = \"./faces/\"+str(frame_count)+\"_\"+str(i)+\".jpg\"\n",
+    "            cv2.imwrite(file_name, face)\n",
+    "            cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 0, 0), 2)\n",
+    "\n",
+    "    cv2.imshow(\"Face Detector\", frame)\n",
+    "    if cv2.waitKey(1) == 13: #13 is the Enter Key\n",
+    "        break\n",
+    "\n",
+    "cap.release()\n",
+    "cv2.destroyAllWindows()      "
+   ]
+  }
+ ],
+ "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

25. Face Recognition/.ipynb_checkpoints/25.1 Face Recognition - Friends Characters - Train and Test-checkpoint.ipynb

@@ -0,0 +1,536 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Basic Deep Learning Face Recogntion\n",
+    "## Building a Friends TV Show Character Identifier"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The learning objective of this lesson (25.1) is the create a 'dumb' face classifer using our LittleVGG model. We are simply training it with 100s of pictures of each Friends Character, and testing our model using a Test Video. \n",
+    "\n",
+    "## You will see how this is an in-effective way to do Face Recognition, why?\n",
+    "## Because a traditional N"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Let's train our model\n",
+    "I've created a dataset with the faces of 4 Friends characters taken from a handful of different scenes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 2663 images belonging to 4 classes.\n",
+      "Found 955 images belonging to 4 classes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from __future__ import print_function\n",
+    "import keras\n",
+    "from keras.preprocessing.image import ImageDataGenerator\n",
+    "from keras.models import Sequential\n",
+    "from keras.layers import Dense, Dropout, Activation, Flatten, BatchNormalization\n",
+    "from keras.layers import Conv2D, MaxPooling2D\n",
+    "from keras.preprocessing.image import ImageDataGenerator\n",
+    "import os\n",
+    "\n",
+    "num_classes = 4\n",
+    "img_rows, img_cols = 48, 48\n",
+    "batch_size = 16\n",
+    "\n",
+    "train_data_dir = './faces/train'\n",
+    "validation_data_dir = './faces/validation'\n",
+    "\n",
+    "# Let's use some data augmentaiton \n",
+    "train_datagen = ImageDataGenerator(\n",
+    "      rescale=1./255,\n",
+    "      rotation_range=30,\n",
+    "      shear_range=0.3,\n",
+    "      zoom_range=0.3,\n",
+    "      width_shift_range=0.4,\n",
+    "      height_shift_range=0.4,\n",
+    "      horizontal_flip=True,\n",
+    "      fill_mode='nearest')\n",
+    " \n",
+    "validation_datagen = ImageDataGenerator(rescale=1./255)\n",
+    " \n",
+    "train_generator = train_datagen.flow_from_directory(\n",
+    "        train_data_dir,\n",
+    "        target_size=(img_rows, img_cols),\n",
+    "        batch_size=batch_size,\n",
+    "        class_mode='categorical',\n",
+    "        shuffle=True)\n",
+    " \n",
+    "validation_generator = validation_datagen.flow_from_directory(\n",
+    "        validation_data_dir,\n",
+    "        target_size=(img_rows, img_cols),\n",
+    "        batch_size=batch_size,\n",
+    "        class_mode='categorical',\n",
+    "        shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Our Keras imports\n",
+    "from keras.models import Sequential\n",
+    "from keras.layers.normalization import BatchNormalization\n",
+    "from keras.layers.convolutional import Conv2D, MaxPooling2D\n",
+    "from keras.layers.advanced_activations import ELU\n",
+    "from keras.layers.core import Activation, Flatten, Dropout, Dense"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating a simple VGG based model for Face Recognition"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "_________________________________________________________________\n",
+      "Layer (type)                 Output Shape              Param #   \n",
+      "=================================================================\n",
+      "conv2d_25 (Conv2D)           (None, 48, 48, 32)        896       \n",
+      "_________________________________________________________________\n",
+      "activation_34 (Activation)   (None, 48, 48, 32)        0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_31 (Batc (None, 48, 48, 32)        128       \n",
+      "_________________________________________________________________\n",
+      "conv2d_26 (Conv2D)           (None, 48, 48, 32)        9248      \n",
+      "_________________________________________________________________\n",
+      "activation_35 (Activation)   (None, 48, 48, 32)        0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_32 (Batc (None, 48, 48, 32)        128       \n",
+      "_________________________________________________________________\n",
+      "max_pooling2d_13 (MaxPooling (None, 24, 24, 32)        0         \n",
+      "_________________________________________________________________\n",
+      "dropout_19 (Dropout)         (None, 24, 24, 32)        0         \n",
+      "_________________________________________________________________\n",
+      "conv2d_27 (Conv2D)           (None, 24, 24, 64)        18496     \n",
+      "_________________________________________________________________\n",
+      "activation_36 (Activation)   (None, 24, 24, 64)        0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_33 (Batc (None, 24, 24, 64)        256       \n",
+      "_________________________________________________________________\n",
+      "conv2d_28 (Conv2D)           (None, 24, 24, 64)        36928     \n",
+      "_________________________________________________________________\n",
+      "activation_37 (Activation)   (None, 24, 24, 64)        0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_34 (Batc (None, 24, 24, 64)        256       \n",
+      "_________________________________________________________________\n",
+      "max_pooling2d_14 (MaxPooling (None, 12, 12, 64)        0         \n",
+      "_________________________________________________________________\n",
+      "dropout_20 (Dropout)         (None, 12, 12, 64)        0         \n",
+      "_________________________________________________________________\n",
+      "conv2d_29 (Conv2D)           (None, 12, 12, 128)       73856     \n",
+      "_________________________________________________________________\n",
+      "activation_38 (Activation)   (None, 12, 12, 128)       0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_35 (Batc (None, 12, 12, 128)       512       \n",
+      "_________________________________________________________________\n",
+      "conv2d_30 (Conv2D)           (None, 12, 12, 128)       147584    \n",
+      "_________________________________________________________________\n",
+      "activation_39 (Activation)   (None, 12, 12, 128)       0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_36 (Batc (None, 12, 12, 128)       512       \n",
+      "_________________________________________________________________\n",
+      "max_pooling2d_15 (MaxPooling (None, 6, 6, 128)         0         \n",
+      "_________________________________________________________________\n",
+      "dropout_21 (Dropout)         (None, 6, 6, 128)         0         \n",
+      "_________________________________________________________________\n",
+      "conv2d_31 (Conv2D)           (None, 6, 6, 256)         295168    \n",
+      "_________________________________________________________________\n",
+      "activation_40 (Activation)   (None, 6, 6, 256)         0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_37 (Batc (None, 6, 6, 256)         1024      \n",
+      "_________________________________________________________________\n",
+      "conv2d_32 (Conv2D)           (None, 6, 6, 256)         590080    \n",
+      "_________________________________________________________________\n",
+      "activation_41 (Activation)   (None, 6, 6, 256)         0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_38 (Batc (None, 6, 6, 256)         1024      \n",
+      "_________________________________________________________________\n",
+      "max_pooling2d_16 (MaxPooling (None, 3, 3, 256)         0         \n",
+      "_________________________________________________________________\n",
+      "dropout_22 (Dropout)         (None, 3, 3, 256)         0         \n",
+      "_________________________________________________________________\n",
+      "flatten_4 (Flatten)          (None, 2304)              0         \n",
+      "_________________________________________________________________\n",
+      "dense_10 (Dense)             (None, 64)                147520    \n",
+      "_________________________________________________________________\n",
+      "activation_42 (Activation)   (None, 64)                0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_39 (Batc (None, 64)                256       \n",
+      "_________________________________________________________________\n",
+      "dropout_23 (Dropout)         (None, 64)                0         \n",
+      "_________________________________________________________________\n",
+      "dense_11 (Dense)             (None, 64)                4160      \n",
+      "_________________________________________________________________\n",
+      "activation_43 (Activation)   (None, 64)                0         \n",
+      "_________________________________________________________________\n",
+      "batch_normalization_40 (Batc (None, 64)                256       \n",
+      "_________________________________________________________________\n",
+      "dropout_24 (Dropout)         (None, 64)                0         \n",
+      "_________________________________________________________________\n",
+      "dense_12 (Dense)             (None, 4)                 260       \n",
+      "_________________________________________________________________\n",
+      "activation_44 (Activation)   (None, 4)                 0         \n",
+      "=================================================================\n",
+      "Total params: 1,328,548\n",
+      "Trainable params: 1,326,372\n",
+      "Non-trainable params: 2,176\n",
+      "_________________________________________________________________\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = Sequential()\n",
+    "\n",
+    "model.add(Conv2D(32, (3, 3), padding = 'same', kernel_initializer=\"he_normal\",\n",
+    "                 input_shape = (img_rows, img_cols, 3)))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(Conv2D(32, (3, 3), padding = \"same\", kernel_initializer=\"he_normal\", \n",
+    "                 input_shape = (img_rows, img_cols, 3)))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
+    "model.add(Dropout(0.2))\n",
+    "\n",
+    "# Block #2: second CONV => RELU => CONV => RELU => POOL\n",
+    "# layer set\n",
+    "model.add(Conv2D(64, (3, 3), padding=\"same\", kernel_initializer=\"he_normal\"))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(Conv2D(64, (3, 3), padding=\"same\", kernel_initializer=\"he_normal\"))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
+    "model.add(Dropout(0.2))\n",
+    "\n",
+    "# Block #3: third CONV => RELU => CONV => RELU => POOL\n",
+    "# layer set\n",
+    "model.add(Conv2D(128, (3, 3), padding=\"same\", kernel_initializer=\"he_normal\"))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(Conv2D(128, (3, 3), padding=\"same\", kernel_initializer=\"he_normal\"))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
+    "model.add(Dropout(0.2))\n",
+    "\n",
+    "# Block #4: third CONV => RELU => CONV => RELU => POOL\n",
+    "# layer set\n",
+    "model.add(Conv2D(256, (3, 3), padding=\"same\", kernel_initializer=\"he_normal\"))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(Conv2D(256, (3, 3), padding=\"same\", kernel_initializer=\"he_normal\"))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
+    "model.add(Dropout(0.2))\n",
+    "\n",
+    "# Block #5: first set of FC => RELU layers\n",
+    "model.add(Flatten())\n",
+    "model.add(Dense(64, kernel_initializer=\"he_normal\"))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(Dropout(0.5))\n",
+    "\n",
+    "# Block #6: second set of FC => RELU layers\n",
+    "model.add(Dense(64, kernel_initializer=\"he_normal\"))\n",
+    "model.add(Activation('elu'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(Dropout(0.5))\n",
+    "\n",
+    "# Block #7: softmax classifier\n",
+    "model.add(Dense(num_classes, kernel_initializer=\"he_normal\"))\n",
+    "model.add(Activation(\"softmax\"))\n",
+    "\n",
+    "print(model.summary())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Training our Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10\n",
+      "166/166 [==============================] - 76s 457ms/step - loss: 1.1153 - acc: 0.5700 - val_loss: 1.4428 - val_acc: 0.4841\n",
+      "\n",
+      "Epoch 00001: val_loss improved from inf to 1.44279, saving model to /home/deeplearningcv/DeepLearningCV/Trained Models/face_recognition_friends_vgg.h5\n",
+      "Epoch 2/10\n",
+      "166/166 [==============================] - 67s 403ms/step - loss: 0.7034 - acc: 0.7343 - val_loss: 3.7705 - val_acc: 0.2705\n",
+      "\n",
+      "Epoch 00002: val_loss did not improve from 1.44279\n",
+      "Epoch 3/10\n",
+      "166/166 [==============================] - 62s 373ms/step - loss: 0.6037 - acc: 0.7690 - val_loss: 0.9403 - val_acc: 0.6912\n",
+      "\n",
+      "Epoch 00003: val_loss improved from 1.44279 to 0.94025, saving model to /home/deeplearningcv/DeepLearningCV/Trained Models/face_recognition_friends_vgg.h5\n",
+      "Epoch 4/10\n",
+      "166/166 [==============================] - 62s 373ms/step - loss: 0.5432 - acc: 0.7988 - val_loss: 1.3018 - val_acc: 0.5548\n",
+      "\n",
+      "Epoch 00004: val_loss did not improve from 0.94025\n",
+      "Epoch 5/10\n",
+      "166/166 [==============================] - 69s 414ms/step - loss: 0.4715 - acc: 0.8301 - val_loss: 3.8879 - val_acc: 0.1534\n",
+      "\n",
+      "Epoch 00005: val_loss did not improve from 0.94025\n",
+      "Epoch 6/10\n",
+      "166/166 [==============================] - 77s 467ms/step - loss: 0.4233 - acc: 0.8524 - val_loss: 0.6878 - val_acc: 0.7093\n",
+      "\n",
+      "Epoch 00006: val_loss improved from 0.94025 to 0.68784, saving model to /home/deeplearningcv/DeepLearningCV/Trained Models/face_recognition_friends_vgg.h5\n",
+      "Epoch 7/10\n",
+      "166/166 [==============================] - 71s 429ms/step - loss: 0.4130 - acc: 0.8636 - val_loss: 3.3402 - val_acc: 0.2971\n",
+      "\n",
+      "Epoch 00007: val_loss did not improve from 0.68784\n",
+      "Epoch 8/10\n",
+      "166/166 [==============================] - 79s 477ms/step - loss: 0.3821 - acc: 0.8748 - val_loss: 2.6729 - val_acc: 0.6283\n",
+      "\n",
+      "Epoch 00008: val_loss did not improve from 0.68784\n",
+      "Epoch 9/10\n",
+      "166/166 [==============================] - 86s 519ms/step - loss: 0.3622 - acc: 0.8709 - val_loss: 1.5067 - val_acc: 0.5197\n",
+      "Restoring model weights from the end of the best epoch\n",
+      "\n",
+      "Epoch 00009: val_loss did not improve from 0.68784\n",
+      "\n",
+      "Epoch 00009: ReduceLROnPlateau reducing learning rate to 0.0019999999552965165.\n",
+      "Epoch 00009: early stopping\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.optimizers import RMSprop, SGD, Adam\n",
+    "from keras.callbacks import ModelCheckpoint, EarlyStopping, ReduceLROnPlateau\n",
+    "\n",
+    "                     \n",
+    "checkpoint = ModelCheckpoint(\"/home/deeplearningcv/DeepLearningCV/Trained Models/face_recognition_friends_vgg.h5\",\n",
+    "                             monitor=\"val_loss\",\n",
+    "                             mode=\"min\",\n",
+    "                             save_best_only = True,\n",
+    "                             verbose=1)\n",
+    "\n",
+    "earlystop = EarlyStopping(monitor = 'val_loss', \n",
+    "                          min_delta = 0, \n",
+    "                          patience = 3,\n",
+    "                          verbose = 1,\n",
+    "                          restore_best_weights = True)\n",
+    "\n",
+    "reduce_lr = ReduceLROnPlateau(monitor = 'val_loss', factor = 0.2, patience = 3, verbose = 1, min_delta = 0.0001)\n",
+    "\n",
+    "# we put our call backs into a callback list\n",
+    "callbacks = [earlystop, checkpoint, reduce_lr]\n",
+    "\n",
+    "# We use a very small learning rate \n",
+    "model.compile(loss = 'categorical_crossentropy',\n",
+    "              optimizer = Adam(lr=0.01),\n",
+    "              metrics = ['accuracy'])\n",
+    "\n",
+    "nb_train_samples = 2663\n",
+    "nb_validation_samples = 955\n",
+    "epochs = 10\n",
+    "\n",
+    "history = model.fit_generator(\n",
+    "    train_generator,\n",
+    "    steps_per_epoch = nb_train_samples // batch_size,\n",
+    "    epochs = epochs,\n",
+    "    callbacks = callbacks,\n",
+    "    validation_data = validation_generator,\n",
+    "    validation_steps = nb_validation_samples // batch_size)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Getting our Class Labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{0: 'Chandler', 1: 'Joey', 2: 'Pheobe', 3: 'Rachel'}"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "class_labels = validation_generator.class_indices\n",
+    "class_labels = {v: k for k, v in class_labels.items()}\n",
+    "classes = list(class_labels.values())\n",
+    "class_labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load our model\n",
+    "from keras.models import load_model\n",
+    "\n",
+    "classifier = load_model('/home/deeplearningcv/DeepLearningCV/Trained Models/face_recognition_friends_vgg.h5')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Testing our model on some real video"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from os import listdir\n",
+    "from os.path import isfile, join\n",
+    "import os\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "face_classes = {0: 'Chandler', 1: 'Joey', 2: 'Pheobe', 3: 'Rachel'}\n",
+    "\n",
+    "def draw_label(image, point, label, font=cv2.FONT_HERSHEY_SIMPLEX,\n",
+    "               font_scale=0.8, thickness=1):\n",
+    "    size = cv2.getTextSize(label, font, font_scale, thickness)[0]\n",
+    "    x, y = point\n",
+    "    cv2.rectangle(image, (x, y - size[1]), (x + size[0], y), (255, 0, 0), cv2.FILLED)\n",
+    "    cv2.putText(image, label, point, font, font_scale, (255, 255, 255), thickness, lineType=cv2.LINE_AA)\n",
+    "    \n",
+    "margin = 0.2\n",
+    "# load model and weights\n",
+    "img_size = 64\n",
+    "\n",
+    "detector = dlib.get_frontal_face_detector()\n",
+    "\n",
+    "cap = cv2.VideoCapture('testfriends.mp4')\n",
+    "\n",
+    "while True:\n",
+    "    ret, frame = cap.read()\n",
+    "    frame = cv2.resize(frame, None, fx=0.5, fy=0.5, interpolation = cv2.INTER_LINEAR)\n",
+    "    preprocessed_faces = []           \n",
+    " \n",
+    "    input_img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n",
+    "    img_h, img_w, _ = np.shape(input_img)\n",
+    "    detected = detector(frame, 1)\n",
+    "    faces = np.empty((len(detected), img_size, img_size, 3))\n",
+    "    \n",
+    "    preprocessed_faces_emo = []\n",
+    "    if len(detected) > 0:\n",
+    "        for i, d in enumerate(detected):\n",
+    "            x1, y1, x2, y2, w, h = d.left(), d.top(), d.right() + 1, d.bottom() + 1, d.width(), d.height()\n",
+    "            xw1 = max(int(x1 - margin * w), 0)\n",
+    "            yw1 = max(int(y1 - margin * h), 0)\n",
+    "            xw2 = min(int(x2 + margin * w), img_w - 1)\n",
+    "            yw2 = min(int(y2 + margin * h), img_h - 1)\n",
+    "            cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 0, 0), 2)\n",
+    "            # cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2)\n",
+    "            #faces[i, :, :, :] = cv2.resize(frame[yw1:yw2 + 1, xw1:xw2 + 1, :], (img_size, img_size))\n",
+    "            face =  frame[yw1:yw2 + 1, xw1:xw2 + 1, :]\n",
+    "            face = cv2.resize(face, (48, 48), interpolation = cv2.INTER_AREA)\n",
+    "            face = face.astype(\"float\") / 255.0\n",
+    "            face = img_to_array(face)\n",
+    "            face = np.expand_dims(face, axis=0)\n",
+    "            preprocessed_faces.append(face)\n",
+    "\n",
+    "        # make a prediction for Emotion \n",
+    "        face_labels = []\n",
+    "        for i, d in enumerate(detected):\n",
+    "            preds = classifier.predict(preprocessed_faces[i])[0]\n",
+    "            face_labels.append(face_classes[preds.argmax()])\n",
+    "        \n",
+    "        # draw results\n",
+    "        for i, d in enumerate(detected):\n",
+    "            label = \"{}\".format(face_labels[i])\n",
+    "            draw_label(frame, (d.left(), d.top()), label)\n",
+    "\n",
+    "    cv2.imshow(\"Friend Character Identifier\", frame)\n",
+    "    if cv2.waitKey(1) == 13: #13 is the Enter Key\n",
+    "        break\n",
+    "\n",
+    "cap.release()\n",
+    "cv2.destroyAllWindows()      "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

25. Face Recognition/.ipynb_checkpoints/25.3 Face Recogition - One Shot Learning-checkpoint.ipynb

@@ -0,0 +1,406 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Extract faces from pictures of people \n",
+    "### Instrutions:\n",
+    "- Place photos of people (one face visible) in the folder called \"./people\"\n",
+    "- Replace my photo titled \"Rajeev.jpg\" with a piture of your face for testing on a webcam\n",
+    "- Faces are extracted using the haarcascade_frontalface_default detector model\n",
+    "- Extracted faces are placed in the folder called \"./group_of_faces\"\n",
+    "#### We are extracting the faces needed for our one-shot learning model, it will load 5 extracted faces"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collected image names\n"
+     ]
+    }
+   ],
+   "source": [
+    "# The code below extracts faces from images and places them in the folder\n",
+    "from os import listdir\n",
+    "from os.path import isfile, join\n",
+    "import cv2\n",
+    "\n",
+    "# Loading out HAARCascade Face Detector \n",
+    "face_detector = cv2.CascadeClassifier('Haarcascades/haarcascade_frontalface_default.xml')\n",
+    "\n",
+    "# Directory of image of persons we'll be extracting faces frommy\n",
+    "mypath = \"./people/\"\n",
+    "image_file_names = [f for f in listdir(mypath) if isfile(join(mypath, f))]\n",
+    "print(\"Collected image names\")\n",
+    "\n",
+    "for image_name in image_file_names:\n",
+    "    person_image = cv2.imread(mypath+image_name)\n",
+    "    face_info = face_detector.detectMultiScale(person_image, 1.3, 5)\n",
+    "    for (x,y,w,h) in face_info:\n",
+    "        face = person_image[y:y+h, x:x+w]\n",
+    "        roi = cv2.resize(face, (128, 128), interpolation = cv2.INTER_CUBIC)\n",
+    "    path = \"./group_of_faces/\" + \"face_\" + image_name \n",
+    "    cv2.imwrite(path, roi)\n",
+    "    cv2.imshow(\"face\", roi)\n",
+    "    \n",
+    "    cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Load our VGGFaceModel \n",
+    "- This block of code defines the VGGFace model (which we use later) and loads the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model Loaded\n"
+     ]
+    }
+   ],
+   "source": [
+    "#author Sefik Ilkin Serengil\n",
+    "#you can find the documentation of this code from the following link: https://sefiks.com/2018/08/06/deep-face-recognition-with-keras/\n",
+    "\n",
+    "import numpy as np\n",
+    "import cv2\n",
+    "\n",
+    "from tensorflow.keras.models import Model, Sequential\n",
+    "from tensorflow.keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation\n",
+    "from PIL import Image\n",
+    "from tensorflow.keras.preprocessing.image import load_img, save_img, img_to_array\n",
+    "from tensorflow.keras.applications.imagenet_utils import preprocess_input\n",
+    "from tensorflow.keras.preprocessing import image\n",
+    "import matplotlib.pyplot as plt\n",
+    "from os import listdir\n",
+    "\n",
+    "def preprocess_image(image_path):\n",
+    "    \"\"\"Loads image from path and resizes it\"\"\"\n",
+    "    img = load_img(image_path, target_size=(224, 224))\n",
+    "    img = img_to_array(img)\n",
+    "    img = np.expand_dims(img, axis=0)\n",
+    "    img = preprocess_input(img)\n",
+    "    return img\n",
+    "\n",
+    "model = Sequential()\n",
+    "model.add(ZeroPadding2D((1,1),input_shape=(224,224, 3)))\n",
+    "model.add(Convolution2D(64, (3, 3), activation='relu'))\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(64, (3, 3), activation='relu'))\n",
+    "model.add(MaxPooling2D((2,2), strides=(2,2)))\n",
+    "\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(128, (3, 3), activation='relu'))\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(128, (3, 3), activation='relu'))\n",
+    "model.add(MaxPooling2D((2,2), strides=(2,2)))\n",
+    "\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(256, (3, 3), activation='relu'))\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(256, (3, 3), activation='relu'))\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(256, (3, 3), activation='relu'))\n",
+    "model.add(MaxPooling2D((2,2), strides=(2,2)))\n",
+    "\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(512, (3, 3), activation='relu'))\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(512, (3, 3), activation='relu'))\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(512, (3, 3), activation='relu'))\n",
+    "model.add(MaxPooling2D((2,2), strides=(2,2)))\n",
+    "\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(512, (3, 3), activation='relu'))\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(512, (3, 3), activation='relu'))\n",
+    "model.add(ZeroPadding2D((1,1)))\n",
+    "model.add(Convolution2D(512, (3, 3), activation='relu'))\n",
+    "model.add(MaxPooling2D((2,2), strides=(2,2)))\n",
+    "\n",
+    "model.add(Convolution2D(4096, (7, 7), activation='relu'))\n",
+    "model.add(Dropout(0.5))\n",
+    "model.add(Convolution2D(4096, (1, 1), activation='relu'))\n",
+    "model.add(Dropout(0.5))\n",
+    "model.add(Convolution2D(2622, (1, 1)))\n",
+    "model.add(Flatten())\n",
+    "model.add(Activation('softmax'))\n",
+    "\n",
+    "#you can download pretrained weights from https://drive.google.com/file/d/1CPSeum3HpopfomUEK1gybeuIVoeJT_Eo/view?usp=sharing\n",
+    "from tensorflow.keras.models import model_from_json\n",
+    "model.load_weights('vgg_face_weights.h5')\n",
+    "\n",
+    "vgg_face_descriptor = Model(inputs=model.layers[0].input, outputs=model.layers[-2].output)\n",
+    "\n",
+    "model = vgg_face_descriptor\n",
+    "\n",
+    " \n",
+    "print(\"Model Loaded\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Test model using your Webcam\n",
+    "This code looks up the faces you extracted in the \"group_of_faces\" folder and uses the similarity (Cosine Similarity) to detect which faces is most similar to the one being extracted with your webcam."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Face representations retrieved successfully\n"
+     ]
+    }
+   ],
+   "source": [
+    "#points to your extracted faces\n",
+    "people_pictures = \"./group_of_faces/\"\n",
+    "\n",
+    "all_people_faces = dict()\n",
+    "\n",
+    "for file in listdir(people_pictures):\n",
+    "    person_face, extension = file.split(\".\")\n",
+    "    all_people_faces[person_face] = model.predict(preprocess_image('./group_of_faces/%s.jpg' % (person_face)))[0,:]\n",
+    "\n",
+    "print(\"Face representations retrieved successfully\")\n",
+    "\n",
+    "def findCosineSimilarity(source_representation, test_representation):\n",
+    "    a = np.matmul(np.transpose(source_representation), test_representation)\n",
+    "    b = np.sum(np.multiply(source_representation, source_representation))\n",
+    "    c = np.sum(np.multiply(test_representation, test_representation))\n",
+    "    return 1 - (a / (np.sqrt(b) * np.sqrt(c)))\n",
+    "\n",
+    "#Open Webcam\n",
+    "cap = cv2.VideoCapture(0) \n",
+    "\n",
+    "while(True):\n",
+    "    ret, img = cap.read()\n",
+    "    faces = face_detector.detectMultiScale(img, 1.3, 5)\n",
+    "\n",
+    "    for (x,y,w,h) in faces:\n",
+    "        if w > 100: #Adjust accordingly if your webcam resoluation is higher\n",
+    "            cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2) #draw rectangle to main image\n",
+    "            detected_face = img[int(y):int(y+h), int(x):int(x+w)] #crop detected face\n",
+    "            detected_face = cv2.resize(detected_face, (224, 224)) #resize to 224x224\n",
+    "\n",
+    "            img_pixels = image.img_to_array(detected_face)\n",
+    "            img_pixels = np.expand_dims(img_pixels, axis = 0)\n",
+    "            img_pixels /= 255\n",
+    "\n",
+    "            captured_representation = model.predict(img_pixels)[0,:]\n",
+    "\n",
+    "            found = 0\n",
+    "            for i in all_people_faces:\n",
+    "                person_name = i\n",
+    "                representation = all_people_faces[i]\n",
+    "\n",
+    "                similarity = findCosineSimilarity(representation, captured_representation)\n",
+    "                if(similarity < 0.30):\n",
+    "                    cv2.putText(img, person_name[5:], (int(x+w+15), int(y-12)), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
+    "                    found = 1\n",
+    "                    break\n",
+    "\n",
+    "            #connect face and text\n",
+    "            cv2.line(img,(int((x+x+w)/2),y+15),(x+w,y-20),(255, 0, 0),1)\n",
+    "            cv2.line(img,(x+w,y-20),(x+w+10,y-20),(255, 0, 0),1)\n",
+    "\n",
+    "            if(found == 0): #if found image is not in our people database\n",
+    "                cv2.putText(img, 'unknown', (int(x+w+15), int(y-12)), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)\n",
+    "\n",
+    "    cv2.imshow('img',img)\n",
+    "\n",
+    "    if cv2.waitKey(1) == 13: #13 is the Enter Key\n",
+    "        break\n",
+    "        \n",
+    "cap.release()\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Test on a video\n",
+    "### Since we're using the Friends TV Series characters, let's extract the faces from the images I placed in the \"./friends\" folder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collected image names\n"
+     ]
+    }
+   ],
+   "source": [
+    "from os import listdir\n",
+    "from os.path import isfile, join\n",
+    "import cv2\n",
+    "\n",
+    "# Loading out HAARCascade Face Detector \n",
+    "face_detector = cv2.CascadeClassifier('Haarcascades/haarcascade_frontalface_default.xml')\n",
+    "\n",
+    "# Directory of image of persons we'll be extracting faces frommy\n",
+    "mypath = \"./friends/\"\n",
+    "image_file_names = [f for f in listdir(mypath) if isfile(join(mypath, f))]\n",
+    "print(\"Collected image names\")\n",
+    "\n",
+    "for image_name in image_file_names:\n",
+    "    person_image = cv2.imread(mypath+image_name)\n",
+    "    face_info = face_detector.detectMultiScale(person_image, 1.3, 5)\n",
+    "    for (x,y,w,h) in face_info:\n",
+    "        face = person_image[y:y+h, x:x+w]\n",
+    "        roi = cv2.resize(face, (128, 128), interpolation = cv2.INTER_CUBIC)\n",
+    "    path = \"./friends_faces/\" + \"face_\" + image_name \n",
+    "    cv2.imwrite(path, roi)\n",
+    "    cv2.imshow(\"face\", roi)\n",
+    "    \n",
+    "    cv2.waitKey(0)\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Again, we load our faces from the \"friends_faces\" directory and we run our face classifier model our test video"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Face representations retrieved successfully\n"
+     ]
+    }
+   ],
+   "source": [
+    "#points to your extracted faces\n",
+    "people_pictures = \"./friends_faces/\"\n",
+    "\n",
+    "all_people_faces = dict()\n",
+    "\n",
+    "for file in listdir(people_pictures):\n",
+    "    person_face, extension = file.split(\".\")\n",
+    "    all_people_faces[person_face] = model.predict(preprocess_image('./friends_faces/%s.jpg' % (person_face)))[0,:]\n",
+    "\n",
+    "print(\"Face representations retrieved successfully\")\n",
+    "\n",
+    "def findCosineSimilarity(source_representation, test_representation):\n",
+    "    a = np.matmul(np.transpose(source_representation), test_representation)\n",
+    "    b = np.sum(np.multiply(source_representation, source_representation))\n",
+    "    c = np.sum(np.multiply(test_representation, test_representation))\n",
+    "    return 1 - (a / (np.sqrt(b) * np.sqrt(c)))\n",
+    "\n",
+    "cap = cv2.VideoCapture('testfriends.mp4')\n",
+    "\n",
+    "while(True):\n",
+    "        ret, img = cap.read()\n",
+    "        img = cv2.resize(img, (320, 180)) # Re-size video to as smaller size to improve face detection speed\n",
+    "        faces = face_detector.detectMultiScale(img, 1.3, 5)\n",
+    "\n",
+    "        for (x,y,w,h) in faces:\n",
+    "            if w > 13: \n",
+    "                cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2) #draw rectangle to main image\n",
+    "\n",
+    "                detected_face = img[int(y):int(y+h), int(x):int(x+w)] #crop detected face\n",
+    "                detected_face = cv2.resize(detected_face, (224, 224)) #resize to 224x224\n",
+    "\n",
+    "                img_pixels = image.img_to_array(detected_face)\n",
+    "                img_pixels = np.expand_dims(img_pixels, axis = 0)\n",
+    "                img_pixels /= 255\n",
+    "\n",
+    "                captured_representation = model.predict(img_pixels)[0,:]\n",
+    "\n",
+    "                found = 0\n",
+    "                for i in all_people_faces:\n",
+    "                    person_name = i\n",
+    "                    representation = all_people_faces[i]\n",
+    "\n",
+    "                    similarity = findCosineSimilarity(representation, captured_representation)\n",
+    "                    if(similarity < 0.30):\n",
+    "                        cv2.putText(img, person_name[5:], (int(x+w+15), int(y-12)), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)\n",
+    "                        found = 1\n",
+    "                        break\n",
+    "\n",
+    "                #connect face and text\n",
+    "                cv2.line(img,(int((x+x+w)/2),y+15),(x+w,y-20),(255, 0, 0),1)\n",
+    "                cv2.line(img,(x+w,y-20),(x+w+10,y-20),(255, 0, 0),1)\n",
+    "\n",
+    "                if(found == 0): #if found image is not in our people database\n",
+    "                    cv2.putText(img, 'unknown', (int(x+w+15), int(y-12)), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)\n",
+    "\n",
+    "        cv2.imshow('img',img)\n",
+    "        if cv2.waitKey(1) == 13: #13 is the Enter Key\n",
+    "            break\n",
+    "\n",
+    "#kill open cv things\n",
+    "cap.release()\n",
+    "cv2.destroyAllWindows()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

25. Face Recognition/.ipynb_checkpoints/Face Recogition - Matching Faces-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}