Face Recognition for the Happy House - v3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Face Recognition for the Happy House\n",
    "\n",
    "Welcome to the first assignment of week 4! Here you will build a face recognition system. Many of the ideas presented here are from [FaceNet](https://arxiv.org/pdf/1503.03832.pdf). In lecture, we also talked about [DeepFace](https://research.fb.com/wp-content/uploads/2016/11/deepface-closing-the-gap-to-human-level-performance-in-face-verification.pdf). \n",
    "\n",
    "Face recognition problems commonly fall into two categories: \n",
    "\n",
    "- **Face Verification** - \"is this the claimed person?\". For example, at some airports, you can pass through customs by letting a system scan your passport and then verifying that you (the person carrying the passport) are the correct person. A mobile phone that unlocks using your face is also using face verification. This is a 1:1 matching problem. \n",
    "- **Face Recognition** - \"who is this person?\". For example, the video lecture showed a face recognition video (https://www.youtube.com/watch?v=wr4rx0Spihs) of Baidu employees entering the office without needing to otherwise identify themselves. This is a 1:K matching problem. \n",
    "\n",
    "FaceNet learns a neural network that encodes a face image into a vector of 128 numbers. By comparing two such vectors, you can then determine if two pictures are of the same person.\n",
    "    \n",
    "**In this assignment, you will:**\n",
    "- Implement the triplet loss function\n",
    "- Use a pretrained model to map face images into 128-dimensional encodings\n",
    "- Use these encodings to perform face verification and face recognition\n",
    "\n",
    "In this exercise, we will be using a pre-trained model which represents ConvNet activations using a \"channels first\" convention, as opposed to the \"channels last\" convention used in lecture and previous programming assignments. In other words, a batch of images will be of shape $(m, n_C, n_H, n_W)$ instead of $(m, n_H, n_W, n_C)$. Both of these conventions have a reasonable amount of traction among open-source implementations; there isn't a uniform standard yet within the deep learning community. \n",
    "\n",
    "Let's load the required packages. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Conv2D, ZeroPadding2D, Activation, Input, concatenate\n",
    "from keras.models import Model\n",
    "from keras.layers.normalization import BatchNormalization\n",
    "from keras.layers.pooling import MaxPooling2D, AveragePooling2D\n",
    "from keras.layers.merge import Concatenate\n",
    "from keras.layers.core import Lambda, Flatten, Dense\n",
    "from keras.initializers import glorot_uniform\n",
    "from keras.engine.topology import Layer\n",
    "from keras import backend as K\n",
    "K.set_image_data_format('channels_first')\n",
    "import cv2\n",
    "import os\n",
    "import numpy as np\n",
    "from numpy import genfromtxt\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "from fr_utils import *\n",
    "from inception_blocks_v2 import *\n",
    "\n",
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "np.set_printoptions(threshold=np.nan)# 全部输出,不省略"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0 - Naive Face Verification\n",
    "\n",
    "In Face Verification, you're given two images and you have to tell if they are of the same person. The simplest way to do this is to compare the two images pixel-by-pixel. If the distance between the raw images are less than a chosen threshold, it may be the same person! \n",
    "\n",
    "<img src=\"images/pixel_comparison.png\" style=\"width:380px;height:150px;\">\n",
    "<caption><center> <u> <font color='purple'> **Figure 1** </u></center></caption>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Of course, this algorithm performs really poorly, since the pixel values change dramatically due to variations in lighting, orientation of the person's face, even minor changes in head position, and so on. \n",
    "\n",
    "You'll see that rather than using the raw image, you can learn an encoding $f(img)$ so that element-wise comparisons of this encoding gives more accurate judgements as to whether two pictures are of the same person."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 - Encoding face images into a 128-dimensional vector \n",
    "\n",
    "### 1.1 - Using an ConvNet  to compute encodings\n",
    "\n",
    "The FaceNet model takes a lot of data and a long time to train. So following common practice in applied deep learning settings, let's just load weights that someone else has already trained. The network architecture follows the Inception model from [Szegedy *et al.*](https://arxiv.org/abs/1409.4842). We have provided an inception network implementation. You can look in the file `inception_blocks.py` to see how it is implemented (do so by going to \"File->Open...\" at the top of the Jupyter notebook).  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key things you need to know are:\n",
    "\n",
    "- This network uses 96x96 dimensional RGB images as its input. Specifically, inputs a face image (or batch of $m$ face images) as a tensor of shape $(m, n_C, n_H, n_W) = (m, 3, 96, 96)$ \n",
    "- It outputs a matrix of shape $(m, 128)$ that encodes each input face image into a 128-dimensional vector\n",
    "\n",
    "Run the cell below to create the model for face images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "FRmodel = faceRecoModel(input_shape=(3, 96, 96))#inception_blocks_v2.py中定义的人脸识别模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Params: 3743280\n"
     ]
    }
   ],
   "source": [
    "print(\"Total Params:\", FRmodel.count_params())#该模型包含的参数量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Expected Output **\n",
    "<table>\n",
    "<center>\n",
    "Total Params: 3743280\n",
    "</center>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By using a 128-neuron fully connected layer as its last layer, the model ensures that the output is an encoding vector of size 128. You then use the encodings the compare two face images as follows:\n",
    "\n",
    "<img src=\"images/distance_kiank.png\" style=\"width:680px;height:250px;\">\n",
    "<caption><center> <u> <font color='purple'> **Figure 2**: <br> </u> <font color='purple'> By computing a distance between two encodings and thresholding, you can determine if the two pictures represent the same person</center></caption>\n",
    "\n",
    "So, an encoding is a good one if: \n",
    "- The encodings of two images of the same person are quite similar to each other \n",
    "- The encodings of two images of different persons are very different\n",
    "\n",
    "The triplet loss function formalizes this, and tries to \"push\" the encodings of two images of the same person (Anchor and Positive) closer together, while \"pulling\" the encodings of two images of different persons (Anchor, Negative) further apart. \n",
    "\n",
    "<img src=\"images/triplet_comparison.png\" style=\"width:280px;height:150px;\">\n",
    "<br>\n",
    "<caption><center> <u> <font color='purple'> **Figure 3**: <br> </u> <font color='purple'> In the next part, we will call the pictures from left to right: Anchor (A), Positive (P), Negative (N)  </center></caption>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "### 1.2 - The Triplet Loss\n",
    "\n",
    "For an image $x$, we denote its encoding $f(x)$, where $f$ is the function computed by the neural network.\n",
    "\n",
    "<img src=\"images/f_x.png\" style=\"width:380px;height:150px;\">\n",
    "\n",
    "<!--\n",
    "We will also add a normalization step at the end of our model so that $\\mid \\mid f(x) \\mid \\mid_2 = 1$ (means the vector of encoding should be of norm 1).\n",
    "!-->\n",
    "\n",
    "Training will use triplets of images $(A, P, N)$:  \n",
    "\n",
    "- A is an \"Anchor\" image--a picture of a person. \n",
    "- P is a \"Positive\" image--a picture of the same person as the Anchor image.\n",
    "- N is a \"Negative\" image--a picture of a different person than the Anchor image.\n",
    "\n",
    "These triplets are picked from our training dataset. We will write $(A^{(i)}, P^{(i)}, N^{(i)})$ to denote the $i$-th training example. \n",
    "\n",
    "You'd like to make sure that an image $A^{(i)}$ of an individual is closer to the Positive $P^{(i)}$ than to the Negative image $N^{(i)}$) by at least a margin $\\alpha$:\n",
    "\n",
    "$$\\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2 + \\alpha < \\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2$$\n",
    "\n",
    "You would thus like to minimize the following \"triplet cost\":\n",
    "\n",
    "$$\\mathcal{J} = \\sum^{m}_{i=1} \\large[ \\small \\underbrace{\\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2}_\\text{(1)} - \\underbrace{\\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2}_\\text{(2)} + \\alpha \\large ] \\small_+ \\tag{3}$$\n",
    "\n",
    "Here, we are using the notation \"$[z]_+$\" to denote $max(z,0)$.  \n",
    "\n",
    "Notes:\n",
    "- The term (1) is the squared distance between the anchor \"A\" and the positive \"P\" for a given triplet; you want this to be small. \n",
    "- The term (2) is the squared distance between the anchor \"A\" and the negative \"N\" for a given triplet, you want this to be relatively large, so it thus makes sense to have a minus sign preceding it. \n",
    "- $\\alpha$ is called the margin. It is a hyperparameter that you should pick manually. We will use $\\alpha = 0.2$. \n",
    "\n",
    "Most implementations also normalize the encoding vectors  to have norm equal one (i.e., $\\mid \\mid f(img)\\mid \\mid_2$=1); you won't have to worry about that here.\n",
    "\n",
    "**Exercise**: Implement the triplet loss as defined by formula (3). Here are the 4 steps:\n",
    "1. Compute the distance between the encodings of \"anchor\" and \"positive\": $\\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2$\n",
    "2. Compute the distance between the encodings of \"anchor\" and \"negative\": $\\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2$\n",
    "3. Compute the formula per training example: $ \\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid - \\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2 + \\alpha$\n",
    "3. Compute the full formula by taking the max with zero and summing over the training examples:\n",
    "$$\\mathcal{J} = \\sum^{m}_{i=1} \\large[ \\small \\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2 - \\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2+ \\alpha \\large ] \\small_+ \\tag{3}$$\n",
    "\n",
    "Useful functions: `tf.reduce_sum()`, `tf.square()`, `tf.subtract()`, `tf.add()`, `tf.maximum()`.\n",
    "For steps 1 and 2, you will need to sum over the entries of $\\mid \\mid f(A^{(i)}) - f(P^{(i)}) \\mid \\mid_2^2$ and $\\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2$ while for step 4 you will need to sum over the training examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function reduce_sum in module tensorflow.python.ops.math_ops:\n",
      "\n",
      "reduce_sum(input_tensor, axis=None, keep_dims=False, name=None, reduction_indices=None)\n",
      "    Computes the sum of elements across dimensions of a tensor.\n",
      "    \n",
      "    Reduces `input_tensor` along the dimensions given in `axis`.\n",
      "    Unless `keep_dims` is true, the rank of the tensor is reduced by 1 for each\n",
      "    entry in `axis`. If `keep_dims` is true, the reduced dimensions\n",
      "    are retained with length 1.\n",
      "    \n",
      "    If `axis` has no entries, all dimensions are reduced, and a\n",
      "    tensor with a single element is returned.\n",
      "    \n",
      "    For example:\n",
      "    \n",
      "    ```python\n",
      "    # 'x' is [[1, 1, 1]\n",
      "    #         [1, 1, 1]]\n",
      "    tf.reduce_sum(x) ==> 6\n",
      "    tf.reduce_sum(x, 0) ==> [2, 2, 2]\n",
      "    tf.reduce_sum(x, 1) ==> [3, 3]\n",
      "    tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]]\n",
      "    tf.reduce_sum(x, [0, 1]) ==> 6\n",
      "    ```\n",
      "    \n",
      "    Args:\n",
      "      input_tensor: The tensor to reduce. Should have numeric type.\n",
      "      axis: The dimensions to reduce. If `None` (the default),\n",
      "        reduces all dimensions.\n",
      "      keep_dims: If true, retains reduced dimensions with length 1.\n",
      "      name: A name for the operation (optional).\n",
      "      reduction_indices: The old (deprecated) name for axis.\n",
      "    \n",
      "    Returns:\n",
      "      The reduced tensor.\n",
      "    \n",
      "    @compatibility(numpy)\n",
      "    Equivalent to np.sum\n",
      "    @end_compatibility\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(help(tf.reduce_sum))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: triplet_loss\n",
    "\n",
    "def triplet_loss(y_true, y_pred, alpha = 0.2):\n",
    "    \"\"\"\n",
    "    Implementation of the triplet loss as defined by formula (3)\n",
    "    \n",
    "    Arguments:\n",
    "    y_true -- true labels, required when you define a loss in Keras, you don't need it in this function.\n",
    "    y_pred -- python list containing three objects:\n",
    "            anchor -- the encodings for the anchor images, of shape (None, 128)\n",
    "            positive -- the encodings for the positive images, of shape (None, 128)\n",
    "            negative -- the encodings for the negative images, of shape (None, 128)\n",
    "    \n",
    "    Returns:\n",
    "    loss -- real number, value of the loss\n",
    "    \"\"\"\n",
    "    \n",
    "    anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]   \n",
    "    \n",
    "    # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\n",
    "    pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,positive)),axis=-1)#这里如果想match给的测试用例就加上axis=-1，但是无法得分。想得分就去掉axis=-1\n",
    "    #print(pos_dist.shape)\n",
    "    #print(pos_dist.eval())\n",
    "    # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\n",
    "    neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,negative)),axis=-1)#这里如果想match给的测试用例就加上axis=-1，但是无法得分。想得分就去掉axis=-1\n",
    "    #print(neg_dist.shape)\n",
    "    #print(neg_dist.eval())\n",
    "    # Step 3: subtract the two previous distances and add alpha.\n",
    "    basic_loss = tf.add(tf.subtract(pos_dist,neg_dist),alpha)\n",
    "    #print(basic_loss.shape)\n",
    "    #print(basic_loss.eval())\n",
    "    # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\n",
    "    loss = tf.reduce_sum(tf.maximum(basic_loss,0.0))\n",
    "    #print(loss.shape)\n",
    "    \n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n",
      "(3,)\n",
      "(3,)\n",
      "()\n",
      "loss = 528.143\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as test:\n",
    "    tf.set_random_seed(1)\n",
    "    y_true = (None, None, None)\n",
    "    y_pred = (tf.random_normal([3, 128], mean=6, stddev=0.1, seed = 1),\n",
    "              tf.random_normal([3, 128], mean=1, stddev=1, seed = 1),\n",
    "              tf.random_normal([3, 128], mean=3, stddev=4, seed = 1))\n",
    "    loss = triplet_loss(y_true, y_pred)\n",
    "    \n",
    "    print(\"loss = \" + str(loss.eval()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "            **loss**\n",
    "        </td>\n",
    "        <td>\n",
    "           528.143\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 - Loading the trained model\n",
    "\n",
    "FaceNet is trained by minimizing the triplet loss. But since training requires a lot of data and a lot of computation, we won't train it from scratch here. Instead, we load a previously trained model. Load a model using the following cell; this might take a couple of minutes to run. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "()\n",
      "()\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "FRmodel.compile(optimizer = 'adam', loss = triplet_loss, metrics = ['accuracy'])\n",
    "load_weights_from_FaceNet(FRmodel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here're some examples of distances between the encodings between three individuals:\n",
    "\n",
    "<img src=\"images/distance_matrix.png\" style=\"width:380px;height:200px;\">\n",
    "<br>\n",
    "<caption><center> <u> <font color='purple'> **Figure 4**:</u> <br>  <font color='purple'> Example of distance outputs between three individuals' encodings</center></caption>\n",
    "\n",
    "Let's now use this model to perform face verification and face recognition! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 - Applying the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Back to the Happy House! Residents are living blissfully since you implemented happiness recognition for the house in an earlier assignment.  \n",
    "\n",
    "However, several issues keep coming up: The Happy House became so happy that every happy person in the neighborhood is coming to hang out in your living room. It is getting really crowded, which is having a negative impact on the residents of the house. All these random happy people are also eating all your food. \n",
    "\n",
    "So, you decide to change the door entry policy, and not just let random happy people enter anymore, even if they are happy! Instead, you'd like to build a **Face verification** system so as to only let people from a specified list come in. To get admitted, each person has to swipe an ID card (identification card) to identify themselves at the door. The face recognition system then checks that they are who they claim to be. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 - Face Verification\n",
    "\n",
    "Let's build a database containing one encoding vector for each person allowed to enter the happy house. To generate the encoding we use `img_to_encoding(image_path, model)` which basically runs the forward propagation of the model on the specified image. \n",
    "\n",
    "Run the following code to build the database (represented as a python dictionary). This database maps each person's name to a 128-dimensional encoding of their face."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''这是fr_utils.py中定义的函数，给定一张人脸图片，获得该人脸图片的编码'''\n",
    "def img_to_encoding(image_path, model):\n",
    "    img1 = cv2.imread(image_path, 1)\n",
    "    img = img1[...,::-1]\n",
    "    img = np.around(np.transpose(img, (2,0,1))/255.0, decimals=12)\n",
    "    x_train = np.array([img])\n",
    "    embedding = model.predict_on_batch(x_train)\n",
    "    return embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''这是相当于预定义了一个数据库，该数据库存储着每个人的人脸编码，这些人是我们希望通过门禁的人'''\n",
    "database = {}\n",
    "database[\"danielle\"] = img_to_encoding(\"images/danielle.png\", FRmodel)\n",
    "database[\"younes\"] = img_to_encoding(\"images/younes.jpg\", FRmodel)\n",
    "database[\"tian\"] = img_to_encoding(\"images/tian.jpg\", FRmodel)\n",
    "database[\"andrew\"] = img_to_encoding(\"images/andrew.jpg\", FRmodel)\n",
    "database[\"kian\"] = img_to_encoding(\"images/kian.jpg\", FRmodel)\n",
    "database[\"dan\"] = img_to_encoding(\"images/dan.jpg\", FRmodel)\n",
    "database[\"sebastiano\"] = img_to_encoding(\"images/sebastiano.jpg\", FRmodel)\n",
    "database[\"bertrand\"] = img_to_encoding(\"images/bertrand.jpg\", FRmodel)\n",
    "database[\"kevin\"] = img_to_encoding(\"images/kevin.jpg\", FRmodel)\n",
    "database[\"felix\"] = img_to_encoding(\"images/felix.jpg\", FRmodel)\n",
    "database[\"benoit\"] = img_to_encoding(\"images/benoit.jpg\", FRmodel)\n",
    "database[\"arnaud\"] = img_to_encoding(\"images/arnaud.jpg\", FRmodel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "dict_keys(['danielle', 'younes', 'tian', 'andrew', 'kian', 'dan', 'sebastiano', 'bertrand', 'kevin', 'felix', 'benoit', 'arnaud'])\n",
      "(1, 128)\n",
      "[[ 0.11276133  0.03207601  0.13590078  0.11822379  0.07636504  0.13431978\n",
      "   0.14880915 -0.13990873 -0.01258973 -0.06264802 -0.06895615  0.05656987\n",
      "  -0.00625059  0.00522547  0.07190287 -0.05568053  0.04310033  0.04391421\n",
      "  -0.04496383 -0.0464243  -0.00843207  0.12305687 -0.0955635   0.17989582\n",
      "   0.01794844 -0.10260746 -0.14342976 -0.03599926 -0.04165843  0.13982902\n",
      "  -0.04188614  0.11941336 -0.12171154  0.05106764  0.08596217 -0.05465613\n",
      "   0.08568984 -0.06256222  0.00192188 -0.03967048  0.1094245   0.00864273\n",
      "   0.06470723 -0.19549362 -0.03102044  0.05460501  0.00480903 -0.02807491\n",
      "  -0.02172411 -0.03455152  0.150454   -0.07591686  0.16888484  0.01827822\n",
      "   0.10440756  0.02885913 -0.00706925  0.07838197  0.01713117  0.01476892\n",
      "   0.01493397  0.11768679 -0.09003265 -0.18028447  0.06014766  0.08900282\n",
      "   0.06730765 -0.0721844  -0.17830266 -0.01774505  0.01251065  0.04428384\n",
      "   0.00113512 -0.01007593  0.00903066  0.14183906  0.02696196 -0.09450618\n",
      "   0.05239265  0.00276199  0.10742998  0.10096071  0.02834628 -0.02422235\n",
      "   0.09584816 -0.04698139  0.00972352 -0.05569498 -0.18729015  0.13399333\n",
      "   0.0195455  -0.04999194  0.08253612  0.05580702 -0.17049019  0.06091601\n",
      "   0.05819915 -0.06772915  0.14484575  0.06185556  0.1364086   0.06831186\n",
      "  -0.01017165  0.06564528 -0.10523929 -0.04865944  0.00053396 -0.06757927\n",
      "  -0.1512183   0.10154685  0.08557729 -0.01880001  0.04089973 -0.09515373\n",
      "  -0.04399641  0.03859749 -0.17101029  0.10744184 -0.19870925 -0.00651667\n",
      "   0.02781366 -0.02077368 -0.01132978 -0.08182196  0.06889162  0.16284062\n",
      "  -0.05861037 -0.14208524]]\n"
     ]
    }
   ],
   "source": [
    "print(len(database))\n",
    "print(database.keys())\n",
    "print(database['danielle'].shape)\n",
    "print(database['danielle'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, when someone shows up at your front door and swipes their ID card (thus giving you their name), you can look up their encoding in the database, and use it to check if the person standing at the front door matches the name on the ID.\n",
    "\n",
    "**Exercise**: Implement the verify() function which checks if the front-door camera picture (`image_path`) is actually the person called \"identity\". You will have to go through the following steps:\n",
    "1. Compute the encoding of the image from image_path\n",
    "2. Compute the distance about this encoding and the encoding of the identity image stored in the database\n",
    "3. Open the door if the distance is less than 0.7, else do not open.\n",
    "\n",
    "As presented above, you should use the L2 distance (np.linalg.norm). (Note: In this implementation, compare the L2 distance, not the square of the L2 distance, to the threshold 0.7.) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function norm in module numpy.linalg.linalg:\n",
      "\n",
      "norm(x, ord=None, axis=None, keepdims=False)\n",
      "    Matrix or vector norm.\n",
      "    \n",
      "    This function is able to return one of eight different matrix norms,\n",
      "    or one of an infinite number of vector norms (described below), depending\n",
      "    on the value of the ``ord`` parameter.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    x : array_like\n",
      "        Input array.  If `axis` is None, `x` must be 1-D or 2-D.\n",
      "    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional\n",
      "        Order of the norm (see table under ``Notes``). inf means numpy's\n",
      "        `inf` object.\n",
      "    axis : {int, 2-tuple of ints, None}, optional\n",
      "        If `axis` is an integer, it specifies the axis of `x` along which to\n",
      "        compute the vector norms.  If `axis` is a 2-tuple, it specifies the\n",
      "        axes that hold 2-D matrices, and the matrix norms of these matrices\n",
      "        are computed.  If `axis` is None then either a vector norm (when `x`\n",
      "        is 1-D) or a matrix norm (when `x` is 2-D) is returned.\n",
      "    keepdims : bool, optional\n",
      "        If this is set to True, the axes which are normed over are left in the\n",
      "        result as dimensions with size one.  With this option the result will\n",
      "        broadcast correctly against the original `x`.\n",
      "    \n",
      "        .. versionadded:: 1.10.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    n : float or ndarray\n",
      "        Norm of the matrix or vector(s).\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    For values of ``ord <= 0``, the result is, strictly speaking, not a\n",
      "    mathematical 'norm', but it may still be useful for various numerical\n",
      "    purposes.\n",
      "    \n",
      "    The following norms can be calculated:\n",
      "    \n",
      "    =====  ============================  ==========================\n",
      "    ord    norm for matrices             norm for vectors\n",
      "    =====  ============================  ==========================\n",
      "    None   Frobenius norm                2-norm\n",
      "    'fro'  Frobenius norm                --\n",
      "    'nuc'  nuclear norm                  --\n",
      "    inf    max(sum(abs(x), axis=1))      max(abs(x))\n",
      "    -inf   min(sum(abs(x), axis=1))      min(abs(x))\n",
      "    0      --                            sum(x != 0)\n",
      "    1      max(sum(abs(x), axis=0))      as below\n",
      "    -1     min(sum(abs(x), axis=0))      as below\n",
      "    2      2-norm (largest sing. value)  as below\n",
      "    -2     smallest singular value       as below\n",
      "    other  --                            sum(abs(x)**ord)**(1./ord)\n",
      "    =====  ============================  ==========================\n",
      "    \n",
      "    The Frobenius norm is given by [1]_:\n",
      "    \n",
      "        :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`\n",
      "    \n",
      "    The nuclear norm is the sum of the singular values.\n",
      "    \n",
      "    References\n",
      "    ----------\n",
      "    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,\n",
      "           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> from numpy import linalg as LA\n",
      "    >>> a = np.arange(9) - 4\n",
      "    >>> a\n",
      "    array([-4, -3, -2, -1,  0,  1,  2,  3,  4])\n",
      "    >>> b = a.reshape((3, 3))\n",
      "    >>> b\n",
      "    array([[-4, -3, -2],\n",
      "           [-1,  0,  1],\n",
      "           [ 2,  3,  4]])\n",
      "    \n",
      "    >>> LA.norm(a)\n",
      "    7.745966692414834\n",
      "    >>> LA.norm(b)\n",
      "    7.745966692414834\n",
      "    >>> LA.norm(b, 'fro')\n",
      "    7.745966692414834\n",
      "    >>> LA.norm(a, np.inf)\n",
      "    4.0\n",
      "    >>> LA.norm(b, np.inf)\n",
      "    9.0\n",
      "    >>> LA.norm(a, -np.inf)\n",
      "    0.0\n",
      "    >>> LA.norm(b, -np.inf)\n",
      "    2.0\n",
      "    \n",
      "    >>> LA.norm(a, 1)\n",
      "    20.0\n",
      "    >>> LA.norm(b, 1)\n",
      "    7.0\n",
      "    >>> LA.norm(a, -1)\n",
      "    -4.6566128774142013e-010\n",
      "    >>> LA.norm(b, -1)\n",
      "    6.0\n",
      "    >>> LA.norm(a, 2)\n",
      "    7.745966692414834\n",
      "    >>> LA.norm(b, 2)\n",
      "    7.3484692283495345\n",
      "    \n",
      "    >>> LA.norm(a, -2)\n",
      "    nan\n",
      "    >>> LA.norm(b, -2)\n",
      "    1.8570331885190563e-016\n",
      "    >>> LA.norm(a, 3)\n",
      "    5.8480354764257312\n",
      "    >>> LA.norm(a, -3)\n",
      "    nan\n",
      "    \n",
      "    Using the `axis` argument to compute vector norms:\n",
      "    \n",
      "    >>> c = np.array([[ 1, 2, 3],\n",
      "    ...               [-1, 1, 4]])\n",
      "    >>> LA.norm(c, axis=0)\n",
      "    array([ 1.41421356,  2.23606798,  5.        ])\n",
      "    >>> LA.norm(c, axis=1)\n",
      "    array([ 3.74165739,  4.24264069])\n",
      "    >>> LA.norm(c, ord=1, axis=1)\n",
      "    array([ 6.,  6.])\n",
      "    \n",
      "    Using the `axis` argument to compute matrix norms:\n",
      "    \n",
      "    >>> m = np.arange(8).reshape(2,2,2)\n",
      "    >>> LA.norm(m, axis=(1,2))\n",
      "    array([  3.74165739,  11.22497216])\n",
      "    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])\n",
      "    (3.7416573867739413, 11.224972160321824)\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(help(np.linalg.norm))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: verify\n",
    "\n",
    "def verify(image_path, identity, database, model):\n",
    "    \"\"\"\n",
    "    Function that verifies if the person on the \"image_path\" image is \"identity\".\n",
    "    \n",
    "    Arguments:\n",
    "    image_path -- path to an image\n",
    "    identity -- string, name of the person you'd like to verify the identity. Has to be a resident of the Happy house.\n",
    "    database -- python dictionary mapping names of allowed people's names (strings) to their encodings (vectors).\n",
    "    model -- your Inception model instance in Keras\n",
    "    \n",
    "    Returns:\n",
    "    dist -- distance between the image_path and the image of \"identity\" in the database.\n",
    "    door_open -- True, if the door should open. False otherwise.\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ###\n",
    "    \n",
    "    # Step 1: Compute the encoding for the image. Use img_to_encoding() see example above. (≈ 1 line)\n",
    "    encoding = img_to_encoding(image_path,model)\n",
    "    \n",
    "    # Step 2: Compute distance with identity's image (≈ 1 line)\n",
    "    dist = np.linalg.norm(encoding-database[identity])#use the L2 distance (np.linalg.norm)\n",
    "    \n",
    "    # Step 3: Open the door if dist < 0.7, else don't open (≈ 3 lines)\n",
    "    if dist<0.7:\n",
    "        print(\"It's \" + str(identity) + \", welcome home!\")\n",
    "        door_open = True\n",
    "    else:\n",
    "        print(\"It's not \" + str(identity) + \", please go away\")\n",
    "        door_open = False\n",
    "        \n",
    "    ### END CODE HERE ###\n",
    "        \n",
    "    return dist, door_open\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Younes is trying to enter the Happy House and the camera takes a picture of him (\"images/camera_0.jpg\"). Let's run your verification algorithm on this picture:\n",
    "\n",
    "<img src=\"images/camera_0.jpg\" style=\"width:100px;height:100px;\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's younes, welcome home!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.65939283, True)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "verify(\"images/camera_0.jpg\", \"younes\", database, FRmodel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "            **It's younes, welcome home!**\n",
    "        </td>\n",
    "        <td>\n",
    "           (0.65939283, True)\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Benoit, who broke the aquarium last weekend, has been banned from the house and removed from the database. He stole Kian's ID card and came back to the house to try to present himself as Kian. The front-door camera took a picture of Benoit (\"images/camera_2.jpg). Let's run the verification algorithm to check if benoit can enter.\n",
    "<img src=\"images/camera_2.jpg\" style=\"width:100px;height:100px;\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's not kian, please go away\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.86224014, False)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "verify(\"images/camera_2.jpg\", \"kian\", database, FRmodel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "            **It's not kian, please go away**\n",
    "        </td>\n",
    "        <td>\n",
    "           (0.86224014, False)\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 - Face Recognition\n",
    "\n",
    "Your face verification system is mostly working well. But since Kian got his ID card stolen, when he came back to the house that evening he couldn't get in! \n",
    "\n",
    "To reduce such shenanigans, you'd like to change your face verification system to a face recognition system. This way, no one has to carry an ID card anymore. An authorized person can just walk up to the house, and the front door will unlock for them! \n",
    "\n",
    "You'll implement a face recognition system that takes as input an image, and figures out if it is one of the authorized persons (and if so, who). Unlike the previous face verification system, we will no longer get a person's name as another input. \n",
    "\n",
    "**Exercise**: Implement `who_is_it()`. You will have to go through the following steps:\n",
    "1. Compute the target encoding of the image from image_path\n",
    "2. Find the encoding from the database that has smallest distance with the target encoding. \n",
    "    - Initialize the `min_dist` variable to a large enough number (100). It will help you keep track of what is the closest encoding to the input's encoding.\n",
    "    - Loop over the database dictionary's names and encodings. To loop use `for (name, db_enc) in database.items()`.\n",
    "        - Compute L2 distance between the target \"encoding\" and the current \"encoding\" from the database.\n",
    "        - If this distance is less than the min_dist, then set min_dist to dist, and identity to name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: who_is_it\n",
    "\n",
    "def who_is_it(image_path, database, model):\n",
    "    \"\"\"\n",
    "    Implements face recognition for the happy house by finding who is the person on the image_path image.\n",
    "    \n",
    "    Arguments:\n",
    "    image_path -- path to an image\n",
    "    database -- database containing image encodings along with the name of the person on the image\n",
    "    model -- your Inception model instance in Keras\n",
    "    \n",
    "    Returns:\n",
    "    min_dist -- the minimum distance between image_path encoding and the encodings from the database\n",
    "    identity -- string, the name prediction for the person on image_path\n",
    "    \"\"\"\n",
    "    \n",
    "    ### START CODE HERE ### \n",
    "    \n",
    "    ## Step 1: Compute the target \"encoding\" for the image. Use img_to_encoding() see example above. ## (≈ 1 line)\n",
    "    encoding = img_to_encoding(image_path,model)\n",
    "    \n",
    "    ## Step 2: Find the closest encoding ##\n",
    "    \n",
    "    # Initialize \"min_dist\" to a large value, say 100 (≈1 line)\n",
    "    min_dist = 100\n",
    "    \n",
    "    # Loop over the database dictionary's names and encodings.\n",
    "    for (name, db_enc) in database.items():\n",
    "        \n",
    "        # Compute L2 distance between the target \"encoding\" and the current \"emb\" from the database. (≈ 1 line)\n",
    "        dist = np.linalg.norm(encoding-db_enc)\n",
    "\n",
    "        # If this distance is less than the min_dist, then set min_dist to dist, and identity to name. (≈ 3 lines)\n",
    "        if dist<min_dist:\n",
    "            min_dist = dist\n",
    "            identity = name\n",
    "\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    if min_dist > 0.7:\n",
    "        print(\"Not in the database.\")\n",
    "    else:\n",
    "        print (\"it's \" + str(identity) + \", the distance is \" + str(min_dist))\n",
    "        \n",
    "    return min_dist, identity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Younes is at the front-door and the camera takes a picture of him (\"images/camera_0.jpg\"). Let's see if your who_it_is() algorithm identifies Younes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it's younes, the distance is 0.659393\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.65939283, 'younes')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "who_is_it(\"images/camera_0.jpg\", database, FRmodel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "            **it's younes, the distance is 0.659393**\n",
    "        </td>\n",
    "        <td>\n",
    "           (0.65939283, 'younes')\n",
    "        </td>\n",
    "    </tr>\n",
    "\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it's bertrand, the distance is 0.467681\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.46768054, 'bertrand')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "who_is_it(\"images/camera_1.jpg\", database, FRmodel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change \"`camera_0.jpg`\" (picture of younes) to \"`camera_1.jpg`\" (picture of bertrand) and see the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(600, 64, 64, 3)\n",
      "(1, 600)\n",
      "[0 1]\n"
     ]
    }
   ],
   "source": [
    "train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes=load_dataset()\n",
    "print(train_set_x_orig.shape)\n",
    "print(train_set_y_orig.shape)\n",
    "print(classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your Happy House is running well. It only lets in authorized persons, and people don't need to carry an ID card around anymore! \n",
    "\n",
    "You've now seen how a state-of-the-art face recognition system works.\n",
    "\n",
    "Although we won't implement it here, here're some ways to further improve the algorithm:\n",
    "- Put more images of each person (under different lighting conditions, taken on different days, etc.) into the database. Then given a new image, compare the new face to multiple pictures of the person. This would increae accuracy.\n",
    "- Crop the images to just contain the face, and less of the \"border\" region around the face. This preprocessing removes some of the irrelevant pixels around the face, and also makes the algorithm more robust.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "**What you should remember**:\n",
    "- Face verification solves an easier 1:1 matching problem; face recognition addresses a harder 1:K matching problem. \n",
    "- The triplet loss is an effective loss function for training a neural network to learn an encoding of a face image.\n",
    "- The same encoding can be used for verification and recognition. Measuring distances between two images' encodings allows you to determine whether they are pictures of the same person. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congrats on finishing this assignment! \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References:\n",
    "\n",
    "- Florian Schroff, Dmitry Kalenichenko, James Philbin (2015). [FaceNet: A Unified Embedding for Face Recognition and Clustering](https://arxiv.org/pdf/1503.03832.pdf)\n",
    "- Yaniv Taigman, Ming Yang, Marc'Aurelio Ranzato, Lior Wolf (2014). [DeepFace: Closing the gap to human-level performance in face verification](https://research.fb.com/wp-content/uploads/2016/11/deepface-closing-the-gap-to-human-level-performance-in-face-verification.pdf) \n",
    "- The pretrained model we use is inspired by Victor Sy Wang's implementation and was loaded using his code: https://github.com/iwantooxxoox/Keras-OpenFace.\n",
    "- Our implementation also took a lot of inspiration from the official FaceNet github repository: https://github.com/davidsandberg/facenet \n"
   ]
  }
 ],
 "metadata": {
  "coursera": {
   "course_slug": "convolutional-neural-networks",
   "graded_item_id": "IaknP",
   "launcher_item_id": "5UMr4"
  },
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}