Face_Recognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Face Recognition\n",
    "\n",
    "Welcome! In this assignment, you're going to build a face recognition system. Many of the ideas presented here are from [FaceNet](https://arxiv.org/pdf/1503.03832.pdf). In the lecture, you also encountered [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 one of 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",
    "\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",
    "By the end of this assignment, you'll be able to: \n",
    "\n",
    "* Differentiate between face recognition and face verification\n",
    "* Implement one-shot learning to solve a face recognition problem\n",
    "* Apply the triplet loss function to learn a network's parameters in the context of face recognition\n",
    "* Explain how to pose face recognition as a binary classification problem\n",
    "* Map face images into 128-dimensional encodings using a pretrained model\n",
    "* Perform face verification and face recognition with these encodings\n",
    "\n",
    "**Channels-last notation**\n",
    "\n",
    "For this assignment, you'll be using a pre-trained model which represents ConvNet activations using a \"channels last\" convention, as used during the lecture and in previous programming assignments.\n",
    "\n",
    "In other words, a batch of images will be of shape $(m, n_H, n_W, n_C)$. \n",
    "\n",
    "## Important Note on Submission to the AutoGrader\n",
    "\n",
    "Before submitting your assignment to the AutoGrader, please make sure you are not doing the following:\n",
    "\n",
    "1. You have not added any _extra_ `print` statement(s) in the assignment.\n",
    "2. You have not added any _extra_ code cell(s) in the assignment.\n",
    "3. You have not changed any of the function parameters.\n",
    "4. You are not using any global variables inside your graded exercises. Unless specifically instructed to do so, please refrain from it and use the local variables instead.\n",
    "5. You are not changing the assignment code where it is not required, like creating _extra_ variables.\n",
    "\n",
    "If you do any of the following, you will get something like, `Grader Error: Grader feedback not found` (or similarly unexpected) error upon submitting your assignment. Before asking for help/debugging the errors in your assignment, check for these first. If this is the case, and you don't remember the changes you have made, you can get a fresh copy of the assignment by following these [instructions](https://www.coursera.org/learn/convolutional-neural-networks/supplement/DS4yP/h-ow-to-refresh-your-workspace)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "- [1 - Packages](#1)\n",
    "- [2 - Naive Face Verification](#2)\n",
    "- [3 - Encoding Face Images into a 128-Dimensional Vector](#3)\n",
    "    - [3.1 - Using a ConvNet to Compute Encodings](#3-1)\n",
    "    - [3.2 - The Triplet Loss](#3-2)\n",
    "        - [Exercise 1 - triplet_loss](#ex-1)\n",
    "- [4 - Loading the Pre-trained Model](#4)\n",
    "- [5 - Applying the Model](#5)\n",
    "    - [5.1 - Face Verification](#5-1)\n",
    "        - [Exercise 2 - verify](#ex-2)\n",
    "    - [5.2 - Face Recognition](#5-2)\n",
    "        - [Exercise 3 - who_is_it](#ex-3)\n",
    "- [6 - References](#6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='1'></a>\n",
    "## 1 - Packages\n",
    "\n",
    "Go ahead and run the cell below to import the packages you'll need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "### v1.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Conv2D, ZeroPadding2D, Activation, Input, concatenate\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import BatchNormalization\n",
    "from tensorflow.keras.layers import MaxPooling2D, AveragePooling2D\n",
    "from tensorflow.keras.layers import Concatenate\n",
    "from tensorflow.keras.layers import Lambda, Flatten, Dense\n",
    "from tensorflow.keras.initializers import glorot_uniform\n",
    "from tensorflow.keras.layers import Layer\n",
    "from tensorflow.keras import backend as K\n",
    "K.set_image_data_format('channels_last')\n",
    "import os\n",
    "import numpy as np\n",
    "from numpy import genfromtxt\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import PIL\n",
    "\n",
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='2'></a>\n",
    "## 2 - Naive Face Verification\n",
    "\n",
    "In Face Verification, you're given two images and you have to determine 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 is below 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'> <b>Figure 1</b> </u></center></caption>\n",
    "\n",
    "Of course, this algorithm performs poorly, since the pixel values change dramatically due to variations in lighting, orientation of the person's face, 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)$.\n",
    "\n",
    "By using an encoding for each image, an element-wise comparison produces a more accurate judgement as to whether two pictures are of the same person."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='3'></a>\n",
    "## 3 - Encoding Face Images into a 128-Dimensional Vector\n",
    "\n",
    "<a name='3-1'></a>\n",
    "### 3.1 - Using a ConvNet to Compute Encodings\n",
    "\n",
    "The FaceNet model takes a lot of data and a long time to train. So following the common practice in applied deep learning, you'll 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) An Inception network implementation has been provided for you, and you can find it in the file `inception_blocks_v2.py` to get a closer look at how it is implemented.  \n",
    "\n",
    "*Hot tip:* Go to \"File->Open...\" at the top of this notebook. This opens the file directory that contains the `.py` file).\n",
    "\n",
    "The key things to be aware of are:\n",
    "\n",
    "- This network uses 160x160 dimensional RGB images as its input. Specifically, a face image (or batch of $m$ face images) as a tensor of shape $(m, n_H, n_W, n_C) = (m, 160, 160, 3)$\n",
    "- The input images are originally of shape 96x96, thus, you need to scale them to 160x160. This is done in the `img_to_encoding()` function.\n",
    "- The output is 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": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import model_from_json\n",
    "\n",
    "json_file = open('keras-facenet-h5/model.json', 'r')\n",
    "loaded_model_json = json_file.read()\n",
    "json_file.close()\n",
    "model = model_from_json(loaded_model_json)\n",
    "model.load_weights('keras-facenet-h5/model.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now summarize the input and output shapes: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<tf.Tensor 'input_1:0' shape=(None, 160, 160, 3) dtype=float32>]\n",
      "[<tf.Tensor 'Bottleneck_BatchNorm/batchnorm/add_1:0' shape=(None, 128) dtype=float32>]\n"
     ]
    }
   ],
   "source": [
    "print(model.inputs)\n",
    "print(model.outputs)"
   ]
  },
  {
   "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 to 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'> <b>Figure 2:</b> <br> </u> <font color='purple'>By computing the 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",
    "\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;\"><br>\n",
    "<caption><center> <u> <font color='purple'> <b>Figure 3: </b> <br> </u> <font color='purple'> In the next section,  you'll call the pictures from left to right: Anchor (A), Positive (P), Negative (N)</center></caption>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='3-2'></a>\n",
    "### 3.2 - The Triplet Loss\n",
    "\n",
    "**Important Note**: Since you're using a pretrained model, you won't actually need to implement the triplet loss function in this assignment. *However*, the triplet loss is the main ingredient of the face recognition algorithm, and you'll need to know how to use it for training your own FaceNet model, as well as other types of image similarity problems. Therefore, you'll implement it below, for fun and edification. :) \n",
    "\n",
    "For an image $x$, its encoding is denoted as $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",
    "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 the training dataset. $(A^{(i)}, P^{(i)}, N^{(i)})$ is used here 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",
    "$$\n",
    "|| f\\left(A^{(i)}\\right)-f\\left(P^{(i)}\\right)||_{2}^{2}+\\alpha<|| f\\left(A^{(i)}\\right)-f\\left(N^{(i)}\\right)||_{2}^{2}\n",
    "$$\n",
    "\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",
    "Here, the notation \"$[z]_+$\" is used to denote $max(z,0)$.\n",
    "\n",
    "**Notes**:\n",
    "\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. It has a minus sign preceding it because minimizing the negative of the term is the same as maximizing that term.\n",
    "- $\\alpha$ is called the margin. It's a hyperparameter that you pick manually. You'll use $\\alpha = 0.2$.\n",
    "\n",
    "Most implementations also rescale the encoding vectors to haven L2 norm equal to one (i.e., $\\mid \\mid f(img)\\mid \\mid_2$=1); you won't have to worry about that in this assignment.\n",
    "\n",
    "<a name='ex-1'></a>\n",
    "### Exercise 1 - triplet_loss\n",
    "\n",
    "Implement the triplet loss as defined by formula (3). These are the 4 steps:\n",
    "\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_2^2 - \\mid \\mid f(A^{(i)}) - f(N^{(i)}) \\mid \\mid_2^2 + \\alpha$\n",
    "4. Compute the full formula by taking the max with zero and summing over the training examples:$$\\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",
    "*Hints*:\n",
    "\n",
    "- Useful functions: `tf.reduce_sum()`, `tf.square()`, `tf.subtract()`, `tf.add()`, `tf.maximum()`.\n",
    "\n",
    "- For steps 1 and 2, 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$.\n",
    "\n",
    "- For step 4, you will sum over the training examples.\n",
    "\n",
    "*Additional Hints*:\n",
    "\n",
    "- Recall that the square of the L2 norm is the sum of the squared differences: $||x - y||_{2}^{2} = \\sum_{i=1}^{N}(x_{i} - y_{i})^{2}$\n",
    "\n",
    "- Note that the anchor, positive and negative encodings are of shape (*m*,128), where *m* is the number of training examples and 128 is the number of elements used to encode a single example.\n",
    "\n",
    "- For steps 1 and 2, maintain the number of *m* training examples and sum along the 128 values of each encoding. `tf.reduce_sum` has an axis parameter. This chooses along which axis the sums are applied.\n",
    "\n",
    "- Note that one way to choose the last axis in a tensor is to use negative indexing (axis=-1).\n",
    "\n",
    "- In step 4, when summing over training examples, the result will be a single scalar value.\n",
    "\n",
    "- For `tf.reduce_sum` to sum across all axes, keep the default value axis=None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-f05732f7068382cb",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# UNQ_C1(UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# 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",
    "    ### START CODE HERE\n",
    "    #(≈ 4 lines)\n",
    "    # Step 1: Compute the (encoding) distance between the anchor and the positive\n",
    "    pos_dist = tf.reduce_sum(tf.square(tf.constant(anchor, dtype=tf.float32) - tf.constant(positive, dtype=tf.float32)), axis=-1)\n",
    "    # Step 2: Compute the (encoding) distance between the anchor and the negative\n",
    "    neg_dist = tf.reduce_sum(tf.square(tf.constant(anchor, dtype=tf.float32) - tf.constant(negative, dtype=tf.float32)), axis=-1)\n",
    "    # Step 3: subtract the two previous distances and add alpha.\n",
    "    basic_loss = pos_dist - neg_dist + alpha\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",
    "    ### END CODE HERE\n",
    "    \n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-440ff81e6bcda96a",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = tf.Tensor(527.2598, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "### YOU CANNOT EDIT THIS CELL\n",
    "\n",
    "# BEGIN UNIT TEST\n",
    "tf.random.set_seed(1)\n",
    "y_true = (None, None, None) # It is not used\n",
    "y_pred = (tf.keras.backend.random_normal([3, 128], mean=6, stddev=0.1, seed = 1),\n",
    "          tf.keras.backend.random_normal([3, 128], mean=1, stddev=1, seed = 1),\n",
    "          tf.keras.backend.random_normal([3, 128], mean=3, stddev=4, seed = 1))\n",
    "loss = triplet_loss(y_true, y_pred)\n",
    "\n",
    "assert type(loss) == tf.python.framework.ops.EagerTensor, \"Use tensorflow functions\"\n",
    "print(\"loss = \" + str(loss))\n",
    "\n",
    "y_pred_perfect = ([[1., 1.]], [[1., 1.]], [[1., 1.,]])\n",
    "loss = triplet_loss(y_true, y_pred_perfect, 5)\n",
    "assert loss == 5, \"Wrong value. Did you add the alpha to basic_loss?\"\n",
    "y_pred_perfect = ([[1., 1.]],[[1., 1.]], [[0., 0.,]])\n",
    "loss = triplet_loss(y_true, y_pred_perfect, 3)\n",
    "assert loss == 1., \"Wrong value. Check that pos_dist = 0 and neg_dist = 2 in this example\"\n",
    "y_pred_perfect = ([[1., 1.]],[[0., 0.]], [[1., 1.,]])\n",
    "loss = triplet_loss(y_true, y_pred_perfect, 0)\n",
    "assert loss == 2., \"Wrong value. Check that pos_dist = 2 and neg_dist = 0 in this example\"\n",
    "y_pred_perfect = ([[0., 0.]],[[0., 0.]], [[0., 0.,]])\n",
    "loss = triplet_loss(y_true, y_pred_perfect, -2)\n",
    "assert loss == 0, \"Wrong value. Are you taking the maximum between basic_loss and 0?\"\n",
    "y_pred_perfect = ([[1., 0.], [1., 0.]],[[1., 0.], [1., 0.]], [[0., 1.], [0., 1.]])\n",
    "loss = triplet_loss(y_true, y_pred_perfect, 3)\n",
    "assert loss == 2., \"Wrong value. Are you applying tf.reduce_sum to get the loss?\"\n",
    "y_pred_perfect = ([[1., 1.], [2., 0.]], [[0., 3.], [1., 1.]], [[1., 0.], [0., 1.,]])\n",
    "loss = triplet_loss(y_true, y_pred_perfect, 1)\n",
    "if (loss == 4.):\n",
    "    raise Exception('Perhaps you are not using axis=-1 in reduce_sum?')\n",
    "assert loss == 5, \"Wrong value. Check your implementation\"\n",
    "\n",
    "# END UNIT TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "            <b>loss:</b>\n",
    "        </td>\n",
    "        <td>\n",
    "           tf.Tensor(527.2598, shape=(), dtype=float32)\n",
    "        </td>\n",
    "    </tr>\n",
    "    </table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4'></a>\n",
    "## 4 - Loading the Pre-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, you won't train it from scratch here. Instead, you'll load a previously trained model in the following cell; which might take a couple of minutes to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-953bcab8e9bbba10",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "FRmodel = model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some examples of distances between the encodings between three individuals:\n",
    "\n",
    "<img src=\"images/distance_matrix.png\" style=\"width:380px;height:200px;\"><br>\n",
    "<caption><center> <u> <font color='purple'> <b>Figure 4:</b></u> <br>  <font color='purple'> Example of distance outputs between three individuals' encodings</center></caption>\n",
    "\n",
    "Now use this model to perform face verification and face recognition!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='5'></a>\n",
    "## 5 - Applying the Model\n",
    "\n",
    "You're building a system for an office building where the building manager would like to offer facial recognition to allow the employees to enter the building.\n",
    "\n",
    "You'd like to build a face verification system that gives access to a list of people. To be admitted, each person has to swipe an identification card at the entrance. The face recognition system then verifies that they are who they claim to be.\n",
    "\n",
    "<a name='5-1'></a>\n",
    "### 5.1 - Face Verification\n",
    "\n",
    "Now you'll build a database containing one encoding vector for each person who is allowed to enter the office. To generate the encoding, you'll use `img_to_encoding(image_path, model)`, which 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": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tf.keras.backend.set_image_data_format('channels_last')\n",
    "def img_to_encoding(image_path, model):\n",
    "    img = tf.keras.preprocessing.image.load_img(image_path, target_size=(160, 160))\n",
    "    img = np.around(np.array(img) / 255.0, decimals=12)\n",
    "    x_train = np.expand_dims(img, axis=0)\n",
    "    embedding = model.predict_on_batch(x_train)\n",
    "    return embedding / np.linalg.norm(embedding, ord=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": "markdown",
   "metadata": {},
   "source": [
    "Load the images of Danielle and Kian: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "danielle = tf.keras.preprocessing.image.load_img(\"images/danielle.png\", target_size=(160, 160))\n",
    "kian = tf.keras.preprocessing.image.load_img(\"images/kian.jpg\", target_size=(160, 160))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(160, 160, 3)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.around(np.array(kian) / 255.0, decimals=12).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=160x160 at 0x7F858E0C7550>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(160, 160, 3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.around(np.array(danielle) / 255.0, decimals=12).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKAAAACgCAIAAAAErfB6AAAMF2lDQ1BJQ0MgUHJvZmlsZQAAeJyVVwdUU0kXnldSCAktEIqU0JsgvUrvHelgIyQBQgkhEFTsyKKCa0FFBCu6CqLoWgBZKxYsLIK9L4ioKOtiwYbKP0kAXfcv57/nzJvv3bn3znfvm3lnBgB5O5ZAkIUqAJDNzxdGBXgzExKTmKQeQAKqQBYQAGCx8wRekZGhAMpY/3d5dxMg4v6ahTjWP8f/qyhyuHlsAJBIiFM4eexsiA8DgGuwBcJ8AAidUK8/K18gxm8hVhZCggAQyWKcJsWaYpwixVYSm5goH4h9ASBTWSxhGgBy4vjMAnYajCMngNiKz+HxId4GsTs7ncWBuBviidnZORDLUyE2SfkuTtrfYqaMx2Sx0saxNBeJkH15eYIs1pz/sxz/W7KzRGNz6MFGTRcGRolzhnWrzcwJEWPIHTnGTwmPgFgJ4gs8jsRejO+miwJjR+0H2Hk+sGaAAQAKOCzfEIhhLVGGKDPWaxTbsIQSX2iPhvPyg2JGcYowJ2o0PlrAzwoPHY2zLJ0bNIa3cPP8osdsUnn+QRDDlYYeLkyPiZfyRM8W8OLCIZaDuDMvMzpk1PdhYbpP+JiNUBQl5mwA8dtUoX+U1AZTy84bywuzZLMkc6lB7JmfHhMo9cUSuHkJoWMcOFxfPykHjMPlx45yw+Dq8o4a9S0RZEWO2mNbuFkBUdI6YwfyCqLHfK/mwwUmrQP2KIMVHCnlj70T5EfGSLnhOAgFPsAXMIEIthSQAzIAr2OgaQC+SUf8AQsIQRrgAotRzZhHvGSED5/RoBD8CREX5I37eUtGuaAA6r+Ma6VPC5AqGS2QeGSCJxBn4xq4O+6Kh8KnJ2w2uBPuPObHlB+blehH9CUGEv2JpuM82JB1FmxCwPs3uhDYc2F2Yi78sRy+xSM8IXQRHhFuELoJd0AceCyJMmo1k1ck/IE5E4SBbhjNfzS7FBizf8wGN4Ks7XFv3A3yh9xxBq4BLHA7mIkX7gFzs4fa7xmKxrl9q+WP84lZf5/PqF7OTM5+lEXK+JfxGbf6MYrPdzXiwD7kR0tsGXYIa8NOYxexY1gTYGInsWasHTsuxuMr4bFkJYzNFiXhlgnj8MZsrOqt+q0+/2N21igDoeR7g3zu7HzxhvDJEcwR8tLS85le8I/MZQbx2ZYTmTZW1o4AiP/v0t/HG4bkv40wLn3T5Z4CwLkUKtO+6Vj6ABx9AgD93Ted/mu4vVYDcLyTLRIWSHW4+EEAFCAPd4Y60Ab6wATmZAMcgCvwBH4gGESAGJAIZsCqp4NsyHoWmAcWgxJQBlaD9aAKbAU7QC3YBw6CJnAMnAbnwWXQCW6Ae3Bt9IEXYBC8A8MIgpAQGkJH1BEdxBAxR2wQJ8Qd8UNCkSgkEUlG0hA+IkLmIUuQMqQcqUK2I3XIr8hR5DRyEelC7iA9SD/yGvmEYigVVUa1UCN0EuqEeqEhaAw6HU1Dc9FCtBhdiVaiNehetBE9jV5Gb6Dd6At0CAOYLMbAdDELzAnzwSKwJCwVE2ILsFKsAqvBGrAW+K2vYd3YAPYRJ+J0nIlbwPUZiMfibDwXX4CvwKvwWrwRP4tfw3vwQfwrgUbQJJgTXAhBhARCGmEWoYRQQdhFOEI4B/dOH+EdkUhkEI2JjnBvJhIziHOJK4ibifuJp4hdxF7iEIlEUieZk9xIESQWKZ9UQtpI2ks6SbpK6iN9IMuSdcg2ZH9yEplPLiJXkPeQT5Cvkp+Sh2UUZAxlXGQiZDgyc2RWyeyUaZG5ItMnM0xRpBhT3CgxlAzKYkolpYFyjnKf8kZWVlZP1ll2iixPdpFspewB2QuyPbIfqUpUM6oPdRpVRF1J3U09Rb1DfUOj0YxonrQkWj5tJa2Odob2kPZBji5nKRckx5FbKFct1yh3Ve6lvIy8obyX/Az5QvkK+UPyV+QHFGQUjBR8FFgKCxSqFY4q3FIYUqQrWitGKGYrrlDco3hR8ZkSSclIyU+Jo1SstEPpjFIvHaPr033obPoS+k76OXqfMlHZWDlIOUO5THmfcofyoIqSip1KnMpslWqV4yrdDIxhxAhiZDFWMQ4ybjI+qWqpeqlyVZerNqheVX2vNkHNU42rVqq2X+2G2id1prqfeqb6GvUm9QcauIaZxhSNWRpbNM5pDExQnuA6gT2hdMLBCXc1UU0zzSjNuZo7NNs1h7S0tQK0BFobtc5oDWgztD21M7TXaZ/Q7teh67jr8HTW6ZzUec5UYXoxs5iVzLPMQV1N3UBdke523Q7dYT1jvVi9Ir39eg/0KfpO+qn66/Rb9QcNdAzCDOYZ1BvcNZQxdDJMN9xg2Gb43sjYKN5oqVGT0TNjNeMg40LjeuP7JjQTD5NckxqT66ZEUyfTTNPNpp1mqJm9WbpZtdkVc9TcwZxnvtm8ayJhovNE/sSaibcsqBZeFgUW9RY9lgzLUMsiyybLl5MMJiVNWjOpbdJXK3urLKudVveslayDrYusW6xf25jZsG2qba7b0mz9bRfaNtu+sjO349ptsbttT7cPs19q32r/xcHRQejQ4NDvaOCY7LjJ8ZaTslOk0wqnC84EZ2/nhc7HnD+6OLjkuxx0+cvVwjXTdY/rs8nGk7mTd07uddNzY7ltd+t2Z7onu29z7/bQ9WB51Hg88tT35Hju8nzqZeqV4bXX66W3lbfQ+4j3ex8Xn/k+p3wx3wDfUt8OPyW/WL8qv4f+ev5p/vX+gwH2AXMDTgUSAkMC1wTeCtIKYgfVBQ0GOwbPDz4bQg2JDqkKeRRqFioMbQlDw4LD1obdDzcM54c3RYCIoIi1EQ8ijSNzI3+bQpwSOaV6ypMo66h5UW3R9OiZ0Xui38V4x6yKuRdrEiuKbY2Tj5sWVxf3Pt43vjy+O2FSwvyEy4kaibzE5iRSUlzSrqShqX5T10/tm2Y/rWTazenG02dPvzhDY0bWjOMz5WeyZh5KJiTHJ+9J/syKYNWwhlKCUjalDLJ92BvYLzienHWcfq4bt5z7NNUttTz1WZpb2tq0/nSP9Ir0AZ4Pr4r3KiMwY2vG+8yIzN2ZI1nxWfuzydnJ2Uf5SvxM/tkc7ZzZOV0Cc0GJoDvXJXd97qAwRLgrD8mbntecrwyPOu0iE9FPop4C94Lqgg+z4mYdmq04mz+7fY7ZnOVznhb6F/4yF5/Lnts6T3fe4nk9873mb1+ALEhZ0LpQf2Hxwr5FAYtqF1MWZy7+vciqqLzo7ZL4JS3FWsWLint/CvipvkSuRFhya6nr0q3L8GW8ZR3LbZdvXP61lFN6qcyqrKLs8wr2iks/W/9c+fPIytSVHascVm1ZTVzNX31zjcea2nLF8sLy3rVhaxvXMdeVrnu7fub6ixV2FVs3UDaINnRXhlY2bzTYuHrj56r0qhvV3tX7N2luWr7p/WbO5qtbPLc0bNXaWrb10zbettvbA7Y31hjVVOwg7ijY8WRn3M62X5x+qdulsats15fd/N3dtVG1Z+sc6+r2aO5ZVY/Wi+r7907b27nPd19zg0XD9v2M/WUHwAHRgee/Jv9682DIwdZDTocaDhse3nSEfqS0EWmc0zjYlN7U3ZzY3HU0+Ghri2vLkd8sf9t9TPdY9XGV46tOUE4Unxg5WXhy6JTg1MDptNO9rTNb751JOHP97JSzHedCzl0473/+TJtX28kLbheOXXS5ePSS06Wmyw6XG9vt24/8bv/7kQ6HjsYrjleaO507W7omd5246nH19DXfa+evB12/fCP8RtfN2Ju3b0271X2bc/vZnaw7r+4W3B2+t+g+4X7pA4UHFQ81H9b8YfrH/m6H7uM9vj3tj6If3etl9754nPf4c1/xE9qTiqc6T+ue2Tw71u/f3/l86vO+F4IXwwMlfyr+uemlycvDf3n+1T6YMNj3Svhq5PWKN+pvdr+1e9s6FDn08F32u+H3pR/UP9R+dPrY9in+09PhWZ9Jnyu/mH5p+Rry9f5I9siIgCVkSY4CGGxoaioAr3cDQEuEZwd4j6PISe9fEkGkd0YJAv8JS+9oEnEAYLcnALGLAAiFZ5QtsBlCTIW9+Pgd4wlQW9vxNip5qbY20lhUeIshfBgZeaMFAKkFgC/CkZHhzSMjX3ZCsncAOJUrvfeJhQjP+NvUxKj9lgL4Uf4FrhdsPPtRJYMAAEzmSURBVHic7b1XkyRbsp33bREiM0u0PGLmzlwJgDAjfgJ/I9/5wt9DMxpJA0kYCRrtwu6oI7q7RKoQW/Bh+c7KBl/wip7aZidPV1WKyIhw3+7Lly93/8P/+N8Dj49P83QGxnEEUs7LsgI5Z8A5/UfAAUM/DMMApJKAOaX7d2+B+zdvgGG39TEAzjnAh+CCA5z3gPdumhbg4eEzsBuG9/d3wBgcEEqKtQC+ZmBZTuf9HlhOJ6Au67w/AseHB+D89DQ974HlcASWacq1AJkKxBi3wwi8f/ceuL9/s64J+PL0BHx+fDycT0ACoPa978fLMQfn72/vgR++/x74/rsfnp+egf/7P/5HIKVSccDPv/wKnKcJV4FasXOFoy3nnN7THqudB+cdkEvRU33wAN4XAEqpenmpBWi/zM5VwNt7Vz2rVA8U59YCsBYP3L77cP/u+6snv65vdMVSK+CoseuBEDsg1wIVux9f1uVm1A1mr40hDgPg+wg45z0BcMgagnMBdJcTC3ldgXFdgbs+vKkrsCkFiDX7koDz/gl4/NMfvvz8EzCfTkBZUj7PQJkXIKRyVwBySkAqddhtgW4zALVWXx3Qryvg989drsA4zcA4z6fDEVjXFTg7l83reIDKY/wEnPdHIC8ppQzUXIHgQ8rl8vUrlfqfnVX9rHNn50qW5JtB2ytqNT/ng55Ucrl+B53DWotOe/A6vNp+Wa8uitdlqRSgxuHtj38DxItnCTEA3jvAO69L6+w7OL1XNV9US8lA1lXpuxjC5Sidw9cKdM4DPb7TMa8rkOZzf9oDd+cTcMPSpTOQlwmoee0CQDwegP6nn++eni7fodZSugi4rgNKLnbwdzvdT8PYA0nufV5q1tnIwHo6piyPloCx796+uQO2uQJTrUutwLwswOl0Pp1m4M/LCpyP524Y2oll3Gz19e1n3OVy6T87dc023JWVVOr15XfOuRCAEAJQqNX8sT25fPXkq79ArfXyJnqGd3L+AGuuyXe8uuhvfsVqtyHBywo9uil0J7gC1Gobuu5V11yHPMYw9F3ngegqEGsenANG54G4zpxOwPr0DJwfP6/nPcByBqaAk3NKC0DJ23EAdiEC33dD992PQOx7YFmXNSWAIDOPbuhoFrFOkw7yeDoA69yF0AHLkoHnw1Hfpes64GYcRgBSKcCaq0KzZU3Afn9+Pp2AOWXg6eHBxx4YhlFnoyjYlFk7FL6VnNtZ/dpkzQh9+4MMzjxzc36e5hEvry+1mHs1O6zy1c1z2FJElqk6ldoQz3P65z/+mVcL/uZX1F1TSomxozn0Uut11E8tts/jgRBCjBGgeqDv+64LQPQF6CGkBKynFTjtn5dPvwL54QFYD89lPgKxJsD76rsIdCEAMQSnD9psgK7rx7EHFHnkeZadeQfgg1N2oVyi1qIoo9c+Dd5Fmln44MZ+BEI/AJlwWlZgXhcg5mwBxE0Ebnd32+c98Hg4AuclJWUg6wqU48l3HdAPPRC6OE0zME8TYNvzi5m1/9nGbM6vWHzkZcEW3JG/fk27Ss0j1GvbddfRFgUst6oeuL97Oxevr5aAStWlVOJbcpZ3uDza8QUPuBBatFmAAF3JQJcByrIcHp+A/adPwOnLZ79/BHZlBQYHeQW2MQB98JQVyGkF4jDWUoCDeciUHwtwOp2A0+loEal3QFomvcrHCMQQN1u7LYB1SfLny5qBVBh3Pe0eXVOezhOwrAvgHF0EGPoB2N7vtuMWGMdn4NPD0/NpvlyVlLJi3dBFoO/7zWZDu+3mZc5fR8Jts9NlbuGq0n3vdfC21nYFL1e4XqXU3ungLU62ILrFdPiSKw1v+Df/+l9z+55XF/3Nr5hloy/3RUuEagWyNvBm4NF5ILf0Se40ptUfj0B5XoDj51+ff/kFWPd7IKzrbXTAmyEAdV2VikAHTGuepxkIPgJLKueUaXZ2nufnwwFYlgUoJaeSLwfpHV0XgdjJZdfsArDJ2mVcqZEWVXWxKy4AXx6egS/Pz+dpoXks791mHIC0JOD2lvubW2C7GYHNMPzhz78AD8cTkF2uzgMpLUBK6zAOwCg7jl5QnbLzikM5rmXFzZQLgA9e4ZXtMnKvzZ/7+pJq2f9sxzQnn83bOyBXlwnAsLsBPnz/3bq559WCv/kVzXApaH9VFBN8u2fswV8BqrnmmAvg0wRwOJczQF5mIP3ys3/8AmxyBnZ9993tDrgZIrB/fj6tK3CUUdYaYg/4fgOk7NJZ9h2AZU4ue8BXWUwu1QHCukPsagjATAFcdQMRWIoH5nmZF8VxASDksz73dAacC303AMflCByPx/3hAPTPz8D94fDDDz8C92/eAt+/f6cYJPzyCXg6nVa5N8EvOU3nQsuahn6IsQfmeQWWdS1XkVF1+GBQEhBiDIoT01f5j85+9c4s0HmE2MjuG/hVr6Kqii+hA1w3As+ncw2jLjC6ogqMC4bReFeBYFFrjd4DHQWI83mdz0A+PgPbTT/c7oA+TcA0H+MyAbebLfDmdrdTtCm344MPHXA+n/UNOyWXOGBNSZiOAHYHMURaaBp8UWobDBN12QIWB4QQ11KB6XgGTufZ8gAfgWk5nZYZcD4Aw9C9ef8O+M3v/w44nI4///wT8Pz0AMyfPxf3UiDZ7m5udhvgw7t7IAT/fJ6ASZe5Fvl57SPOewN9QwTi0s3LrK+GgYBwqcR437yuXVoZmG2UX4NiTgBEu/ylluuU2jmvc6Vj/pc//rH7kHh10d/8ikFIUux1/QXllJIsgKoKeeiF3ZQVcNP59OUzsB6fgXS7Ky4DngT0JaW80jLdSF2XBVgBKDjhunNagdB1uuMsxczZgo6yAqXmwguA7rzdvZbLlayiW9f3gHde+ej5rNinhK4HcsrA8bwsCt+Cdpl1VxwwbHdADXFzOAInmeZ0/PTwACjffZ+z3MDYReBmHJNsV8ecUAlASNZ8nnKul6Ma+r4VA2adWCU3rVBBK9tgP+ofltlj+6Z78epArQnItar4UQ2C9go5Q4zA09NT3214teBvfsVwcdytYgPUkp0AoJKB3jOo2DevwPr0JRwegaEmIBzWtc5A6gMw1uxUElon4HSoKkH62CHgNDgg9la80v1Yix5zWgQOq1qVDffRX2spKknJgqmKa0KpwLrO52kGllXG4VOZARluSsUixJyB6taHL18AvSSVqtwm9gMQcz6vE/D54QlwPmw3WyCrpF5L33XAAMBqkR9OKWVOZaqAYId+GLoYeUGbVyFLpRQamM+VydYr+6Za1uQstar1KnctWe9BRmejdD4Afd8D9F0XVCDwHqNqvDhD72oIFQi1ABvvh1qAdDwA7J92JQGbTkUFRldpeFbxNWwHHQGwLouuRyiW6ula9va1LcgorgKlrMr9FCA6iyoI5p0sa2zovfMhXK7ZupxZE+CKCq4ury+nMoZObjabMyzz8Rk4HQ9Art7KdtEBoYtlBThOZyDu9yo1KpjPxQKZGDqgj8VuKR2qVdNZlxWopcpXx14p+2jQYSlAP/Q6SzrIWsvFR+srWJhcLfKqBgMU+w4VINcMJNJNPwAfP3wA+vv3/vY1D/4rWFHFphC8YdZFuSOD6gdkYCg1lgyIbjFGxtgBfXBA50rvXlAwKKELNKi2ei8Ly2lBRAvngH7sgXHodHuuvShLQ/QvfC5CMJOtBej7QagvllOtyzwDx+MJ2Ee3ncURk5Mva+eAJIeGF1pkdYtSl2KuG0jZCedy0SNeQ/XAkhLKKVFFpAcgFF9pkHjf98acktW3OrxAt2VpdRo3AnHoGrFCOPagr9BstNUHWzzV6gdK9Is9rT3qaUIVvXfvP3xAKDRs3rxbQuTVgr/5FWV2JVT9IxfRKKvnBehw6+pSAnZdAO4/vt8FD6zTGVjnkwVKRgdogQy2n3V9B9DqaF0MwHYcge129FfJ+2YYVLXECoIWIuie7WIUsKz3n87n8+kMzNsNMN/eHKYJeDqegPN5svq5j4CPXUGor/Bb1pSB05SA/Xk9zSuQFIgEX30HTAvAtCbOMzB0ojlUy16CB7xzyjDpFKVaVV6+IuWc1hUMraiO2BkMBwRv5ULlNm5dL/urfWvzDQ1kNAKdrQtXCAjBj+NAS8+Crx0JiBa/ZRwFCMVgEiV5Scy0Zd5Qgc5XAN+ZC1HNq0HnYmy5EHSU+vht3+/GkeYrnHcKr8bNAOx2G13RGAPKGmPUKQacD4p95Li8c5bFrivQ7bte91kMwOLDEF6IJfNgCUIIPdopGigPlIp4dNNcgP057c8zcFoXYK7lVBZALznPyzQvQM26wLmKuSYey9CrAm27SamKyFQdr67luBYIZ+FuOkU5GxrVhwik0K1FCG4BXKlGBzE2Xbu4FieKc0ZS0dbZnlhESVuX9SuO7ev6Rle0+yCV9rNQGb9OC3DeH4AuLz42vBvcQgoeCGsCYilKAV10QNcAdN3X97ubm3HLJdXxTklkN/RAPw6h7wB3SRaNbxUAuo5+BIg9UENQ7BXnCaD7YvEaHuiK93bPJiDVPnYjDXxeUl5SARZ5zlTNv2lv6Dtx+rvogUNal/lCsKJShc0JOfIuZOUvyQE7v9tudkCUhyBrM1LCGbpgVBmvKLLIdtdVBdAiu9fWMxbzyetagOIaG6teTr7tL0CptcF8FfAxhj7QEk5cTf7Vgv8KVqzGyarKtb3IKPiKB7zl0rnIsLEnaxMyWnapgkn7YQB2d9txOwDqHLndbMZoWDHgnPdKwLoOIEbZrhmu89plq3hV48jtO4Cbt4AzJiScT0AYb5z21/gE9N2xnxVlyGTXSqAhG3nNJa3AOidgXfO8JiAl5SeuffECRFcFxRcD1MpqT7MISOARi/mAYdgACpdyyY1HKfzc/JmCrLLmtCawsCLEqJMmr7bZBLHMpikAy7KotcUIU3ga1ZtmuDQ4bDcON+MAKBDxXUCuMK0L4KtRpRCEVsugwGE7AsxFvUNbH4Gb4LY6aBYEGW5G4P79W+Dm3e2w6YFRzLTYRRd4Aaeck8tq3TgG1V8KY/pRLrrv2e0A7t8CdXNr5NNlAnyvCoiFJNERxgj4IQDTeVJklOZF5131DH3fdS3JcC47YzUr2MxY2l2AEASUIveuGkPJlJrAOMWhm29zooWvLmX5VatA1LIuE5fqQqklyflXoIciynvjHG7GDWC58tGLdmJBq2tMrUam1WXXid2EcBMicKPqoXedTjCv65te8fD8CGyHofeBVpYPpQwhADe3t0C36VU3jHkB+poUmig+6jbj/bs3wJvvPwC7d3f9ZqDldr5WlwqgR0r5uord2m9odMKrPxKEIJlBlxBlwWLauqET8T2MHVBnIx32DECxj2VN4i8mMRo6bTrGFTDAPOUcXKLlNj4XtTfq9g8+WOiZAbKr1gSTM3A6T6fTGdg0R726FahqZ3L21bIZrrOUV1/TOwVf2h/XWtR+0AkM2FSdjnluJC9vtX3AlRoqtJZPN02Hv/wF+KTGrc3o+lck669gxbTMQIm2vXfOAV11gxiKXmybUqYVqMsMVJLvBVNsgfv7u/sP74Ddh7dAf3djFqb9LSXrwhVefekY06r1xXaB6vQ00gqwnJkPANMe8NWqS245ARwe3PkZqKtRwlSnKi98F+M9AeM4qv4vg17XvIpBljKwrut5mQG/ZqCs5ZwATsEgC4sTLsiweylqTfP8+LwHVFIch95bJ7Sh6LIw8chqI9ZYzFWsu6w9uYqnbaCG97vNBvHT4FRzbnR5IDiLG/TXPqfl8yfg8flZ76+nRTlbV4tROEIAerxbF2CZTgDnI/MJUBXN934ceuDN23vg/Xcft2/fAOF2C/ihszBPjixVd3UFaUhbq0xcgkELHKp58gRQFqeS6FwBNzzbk2dd4C/18TOQD89APc+qHFi+28qUFuH3vRyaCttpTXMMNCbJ2u5vQgKyzzfFAWsJwLwwLQIyC5BrMc6UU7EyqdpxPJ2Aoe+0F+iLrWkV+qvKpvPRG4NO39mrthgFDIcgYFE+GcfYDYAovZVynFVVFM3GqcwQSwW23t/p2gmTSFkZ0KuL/sZXFHYTPE5hhe6sUqbjEaiHJ6Bb54HCpU6wGe/uboD7+ztgd3cfdlvA2j9qNVxs1a3U2pzKC4J+dQANOX+xcqtiA+Rc52eA/QLQ9fYm8snnQzqeAIFu65rVKpiyEtykSnirqVnbuj4veicwzuIm76KPQBcdMFZ/W2RnPZCzX9MBKFlpIcUrPfVAdl5VDQuFalFiKh5q9c6qe4IQarEGE2vqtb+W5myEnw8DQMpZxiq3utmOQqlOy4SafZTT4oCt83chAht1iQaz7FcL/sZXtMZAU0qxWzpN03o+AH1JwNDFjQPYDgG4u729v78HNrsbwPeD5dy5maZuUquaXbpar1uy2j9qq7NcOjosBTF+D2UGqCILOFSXXGcgL9O6ZGBeKzDlqvvdoOBqnVvVuNOXGpx9jrswGYHiZI4Cu/sQxpiB1Bcg4SdlUxY3OF88MJUXvBouXcI1xktBD++Dry8ssyXN4lxazhZsS7bKZk6CvdQ/13XVLodCTm8luOorME1ZgUrvAjD6ENSK5wVV2YmNtQgERwVgp7OTZrGxBhHkIAYH7DYjcHtzs93eAP24BVzsag1g4DvYRXK5sens0l7I+1dU75cfsesqgngW+6LIdxk/tJSSE5DTDOR1FSi/yDMX+wjXmvta9Ga0cbvexltzVjcsctTW9dm6KdsBObsY22EDTKtqfKd1rTSsKlbDv+Y5Acuc1KKIU8khK7yqawLWydi7cuO578VskXn56FT/zjWhQFiGkxOwLItovIMqvq4KWdvUCAxdF9QAUNrXra8u+q9gRbu/vZc3EEmD8ymWBDhRMkuRhoG67W63O4NMux6gGBxjq7b6/8VGv0p8Gw2hNFdcrwvipRU/CrCmrI6PkoyJKINW8poXA+6zURLNCzcOlP9az8YpXVPimV2Vu1kVtNUqCpXkc3K9kKHsxTKam7EC85KOcwK8MTTNQakC+LzfbzaS3PJ6w6arIj5Jlb+V15nXeVs3gPMbIHbeuw6siJlyEhwmv+2LE6wtnGvous1mB9yqDb9r/WS25dmhv1rwN77iBRg2o5lmoJ7PQ05AHwDGGIaNWmBHYOh6q94rDymr7uEmdlTdi0kBrlln22uvLTi3+nWTYdB2K8hiSsuyroAYzrUYQ1GGu86LDLp1XxkK1oK2arwiZxQZE6vQh5eykAE9ppqz7c12UIoMRBjyFCWTAhx260asAb+uwJzS2hqFgaenp5vbLQ3YqrVe4y0hBOEeisjqWi9tOEAt2d9AExq4UKydYc7eKO/LCtC4rbvYA12IzekU2vHrAtsHu2UBptMZWPcHubLdbgP04zBuNzS1Gxe8RbnzDKqfZaCqfdG94DQA+K+jKmcevBiD6UIKA0qqcr9C7Ka0LOlFUbEWiyqb8lnD+VrrjjOqXvvwdqX1saoqijCVc9ato270tOamVaPLX8XNs8Kf0THoVYAZN7o5w7IAQ07LEoHj+QSUkk7nEyCwL/igu1MtYOECmakonMs8nwFlB8GzlTiJyR16Q3sXFQ1xTgJhCajz6noPdEMEolct276md07f/9VFf+Mrhk6kxihvcDocgHW/lzfuBI5sNirpG5fdOaN/iOeQi+sK4Drd2KExEISql0aoBEt4hNQrnKlZ+U2qelwstU3AnA2cuvRuNIU5Iwu46/vTu2AGZ/6jXunI1IJXQqiMay11UV3BYitlTc1R19bhYo7AepYdwBhDUv+Pmp2IyxCB0DlgWhY1rQjY6mMUlV/eNUY/DD2gsv+0zEqBeu+AwUf528HKCd71AZA2w7lOFglqH1mXKj8wijrSMsB25NbL/198K7yu/yqXWbAPQQn4Mk2Ar24zjIDUH/u+7/uBFnSkUlahoE6KVNWtGXDaSKJzSp9ChMYfulhhKJiwywpMy5rWF0sqWfuLusjIzhdeCnNQsc2pAr5emN+iK9uWFRpk1mxXHGMBD5c4ytAo+wq+XGtOVXdR/3VAwDRoREkL1DGKXxaBVJxQIIEVIXildtM8A9EFMZYMg/NOFOhF52RNkQLcb7bA2822U552OAHO+74fgc24BTrvJSe1ugIk54MVjgpAMK2r1nls3i2KG1VrtbguV2AzjrvNlktvtQ9y4JL2C67oFEcTeAARIfRJnqBkrtsAhOBaBUOXripEMtraNF+111HaqRRTqRQFJ9V4Ri9SNXq0SNH4/p5QL29Va5FeVVKnUM1rfikmrtlUMVYRUb2/dGTrHT0eiMZXrQrBrLYagg5EmkNL9eo6xMh11pPYwuPSGztLQSW6C4Vf3ozD3W4HfHzzFtj4uOwPwHo665bdbG+B/t074KYfVT84nx2wBiveq6rh2nm5qr++Bll/BSsqqp7XdD6daMlcHAeDRYzB5EQfl3mtGbcUIPgV8KEJmUbLfIyCqr7FrlOk4NTKEVbdnjKdFWc2pISnPajXr7rcBKTMONoyz1yvzC6VbOCY2oXTqjBH6dCa0noFe5VqkJbMveRi1DADv7zd/jKR1npp5HVvPkP6PcEHVVpLXoGV0uee5gtLztaj5bw+Tm0/t5sdMN51d5stsOl6hKJngM73iGJqopATMNzdbPsNEKoHVh+90Um1X7j6sl9doPdXC/7WVxRXKC3z4XwE5nUG6qZX8511D/sYDcSIQMbNQmcE+WTnLepRoXuNzEDvOmCIg/M9QNcB1fn1PAMSOVqaBSt6qkaMND56yi5dlYAorS4FQCnZunuTFVumdQWmhmAYiJFan78pI+mxychp/y7la16Rk5pTMLGjy49KPGzQgv4XvZEuJYBFrayKV1agrKviRBXtO5wLL4IWm3Ecu56LmlVxiqpclHcxuc3Tfg94V4WODTECoW3kcp+XE3PRB9dDVHic51nwkFgQOedVNUgAQohSblWTTGmQvdXV8iWsTUBH6JDrXoCY5rroNPVArU5qVg3lN/UdY4iFoPcUK+OcW+hntIdqWvomypHOpwk4qzHwPB2nGTjpupbS7hwH+OCjqPzRStf5qkuAYpmvypSuncSxAxj7zqAlXVGC0LGGfVZR5tTG6Cp1UfwmC8FfaWtTQwyVpq47xm5Q6dfgN6PFK5NOc2u/WE/AmpZ8m4C+U+TrJGRqFcbSYk9jsBg559VFf+MrqnFowst05KnWdVWUb/xQ55Juh6b7bqBJtvK4ZU22rUcflekmIOelroqbAGp19aWeTmngsGutzbJO5WPnxQKl3LppZ7nfOQHn83Q4nIDj8Qycp3kWLCU8rYvSCBUYRwjpIoUNOed0hXLnVC+cAh2M8f4Ho8WrkUd2HLyLNmZEX6TK7VeJT8S+xAT4vgKpVJN30V+pyq3VJN13/SAcQlaYLMoSYrXmnCwENlVEmeO2iWkH29csl3PXHQVNsOfVgr/xFcfQAWtxRehRqkBeTfdSN0XKRbu9b4MHbFO8UMwBbNhKwSkxaPV+Zzt3srTEqxfNCedy2lZV2c7edB+lZHmeZymyJ2Orp9M0Ac+HE3A4HLX7TmblVdqkkorshqHbjIC2XueanHdRJSovpvJkzAL7vm1LtpwqJWCeJ0nSqEB0M4wbRUytbdALs3NWlk/S14xFp1MyAd7yTV/N7Oz06sRKUznNRqKWNmDJ2TB9Ea1LFYk/NA1xITnRFbtSFlnpKtg/Yie6qA/KrqzklGtrD/J6o2TUAuF51uhmu7p3rTU02OU3j6pwqYiOlI3QlCXTbtogxW6dvKh+xrrOwOl0BKZ5VrnQzsK6Hk5n4OlwAA7HczKsCsDF2PWDLi0Qh0H/UIEEVw2kVA+lK7qkKxVYSlWTkgUmpeFBWf2JNXUebB5bjVEdqr3UPzCQoCnhsnYdrWg911Ymt6zUFf+i7XU+n5ZpATTEqeRs7EVTsfZSMhlF8qJqKogeXXP7TRyi+pcyLBeRrVcX/Y2veJm8JT+jS+5aG47xzHPxWZqGgjeti9d2de/ttU4AssVEqvT5NS1KalMFlmVpvMYCLOd1nUWzMs7GMi+A+mLPixX8RYpY1qTga1EqhbO4SVTTvu+3W5ryOs7nVjbXj6mswKxJWKlMSwHOs3WFV4v1CtBRB7HkXQGit5jodrMB7rabrSz4ghkVbWQAzoW1l0KPUQnU237pZvRt1wPmZV3nBTDJYdPCt0iw7zovnGsUd8B0dJSU11LqpaELuEILQMyZ1yDrr2BF1W3oOqeBog4gUVvtRZWf3F0EbgHvTYqttdG5q81gzaWuGchuBk7TInq6kdSXpenCKcZZLam3xkCLbjQqZVnWNSdgzRWYlywRd6tsJptEJc2pOIxiFDU2elWhTDoL5/Pp6ekJeHp+BuZlNTeTpOBncz9VaqzeJvQomnn//t3f/vYH4N3tDdB7NCnGGSWtwT4GuhnPTUUe70q+ClgusHtD+q2RpzZg/AqHwjXcTTz4S9HWiKe1eKulytnY61508CpAzF0Aupvt7bu3wNNPfwHmdT4vCyAPWUr5auRWpVUb7YCNzZpXYFmSQkFz7ylJFiNbFF0vRHSMSOW4ZLq1GDfKBFXJrdsTmOdFYbMe52VVRCpwquAWXXFtDa2/QAfzuN//8U9/Ar58eQBSqRIJGeIA7PqNyrSm0VHd7TAAv//+PfDf/P3vf/vhLU3YcT0dLOG29ovibSitnQ1r2LT/oWhOrYje+dLyEyB2qvhd5LLLNV83xtjGQXpgaMK1y/Kifsil8HJdNachFa8u+ptfsUhi7v72/W9/Azz+/BNw+Mufn6cJ0Hiw+2zk7iZQbBM+lfmsa5KzlOD64XhQtnrp1TFSrTdxnVHDK9o0W3V2vAz+k1Ga6I6z0Gxe9P42Y0yRUTa2l2pqYV2NqiUF7JyjSfYOwGa7lQPXiIgOp8NQT8ou9KP3QO8rcD/Ef/rtj8C//Ye/Bf7m41spWJwPz8A5hKpcpIKStCsEyQUXoueSvK4pmxKdgllvjHv5zxCEZDVtK8u8Tf9rGIINgwUY+s7m0hnHtBBln233vCqflPYRrxb8ja9YNMy5H3YfPgI3P/4APDx8+jLNwPtpBt7lsrNWLQesJU9pBc6nGThP0zRNgFQQzvMkANkUsasBraqXjeOmusvtRa8CJPYLh1NhvGuSpAq+FOvNyzov2uwNQjHiu1jpblTdJi2qZdXutgfubm6BvuvV/6JZMNQqC+4Eq+XcU4E3mw74u+/f/7t/+nvg9z98B/S1HPfPgKUgwQstcfr0NrnUONU++qEHomTxlkWj19Vr6Z2rV0yKUks3qnVsAOqY+74DNBs1r6mWFeg7NadEI0inlQulkwvP3bX2Se3BvnUXimngXLe7Ad788APw85//uP/pZ+Dz8QB8nKa73Q3gnMieq3RdreCai0RaxbILm60GB5VuAVY5WUzqrHg3GXUrAXiN6SbacFubU937HuiWzk+iWOiKZqWPGCvdNTZWBWLwpY1nBTbjqJLcOs+6GO9ub4GdBHvWVEwePgMu1LvtAPzDjx+Bf/O73/z+x++Bm74D8ung2kwBYK2l6SGqFFGy5iEqXHK++A6oNl2EolZEJdbRu6vK44VBJSf89s3d9x8/Agqmnh4fdPBqtB+6OJ2OgNpGQ2ddKdmkX79uN6jGGHx10d/4isrh1lp1v9+9/wh8/ze/Pz0+AT9/eQA+3r15d3MHNmhinmdypjnS2PuuDnoTIJTs1wWos0UZpiEoQmheNTCsJLmYqtZyiS075wQdD0Hoa84iOs0rcDw45amiX9Tgha9L7bMfxnDF7e37Ttz6Nam/pnbBAf1ozykaXOUBdmP//ft74B9/8wPwux8+qr/IzROwLss0nYH5PAHzeV4WwQMVWLL1gQtHXl2uNmJMH1sbyxOUm0sMxur/NihL0hH3N9ttH2nNKfe7cfPhAxCHEdjvD+KX6Z1D6wn6asoDLSN21hL2asHf+Iom9wjFeWC8vQN++3f/eHp4Av7l//g/gJ8+ff54/xZ4e6Od2A3jCHYbZmsHsW2mpHXR7SQ8CwOQs3riSo5xBbo4A0PslpyA3ViADcNQKiC1y83wZtN3tK718/PhVJs8g0iNKp+p4p2LJkP1wwj4YKorirx8sWJL5zug67oOB+zGAXh3f/PxzS3wg+Q2x40io+VwAk6HkzgFmmp8ajO2mpKeaVgKsSq+tqI9AK2KZ9K/zmOonzr5s9Ah2fM8n5+fMiBnc3dzs73ZAOe1AIfpPK2mAsML2HzBoo347l4o0gaoiU9kwaxinLff//gP//a/BdbjBDz//Odfn/eAZmKMfW/JKwDFpDlRu8Oai4AeMaT2h8N8OtNEQWsxSYOhN9aZvpzkVvsU1Yunb/j25tbf3QI3+rjTaT0eAKmzF+cQgU16OeuaFU+JLBH7YALwupHpqwOU7w7e72IH3N9s9Xi7HS9/zefpdDwCp8dHYH/YPx/OwOE8Aad5npP2NWFwRlax4m1wppClOjeuDaQSy8Wq58VYtMlOnnfANNNHD+y2N4CPYX/cA5/3Z+Dh+Vk3lvKRims9YC+OGlrv5mtv0l/JitIgjTFez2gJofvx7/+BNpTj//33cZ8TcCwZiE1Uy3xULueUgOM8A/vTeX88AY+HA/C830/7E7CczwBU9S3ubrag+aqB1lreu05oWQfA7RC3Qw/chu8Av0yKev7086/A0zTr9o9hBIJzfk20vuyuC+IyyDX13m1iBHaaP9j1qv1JY3nsQ6wFWETvWpbj8wE4HvbA8XQ+ia+pUuaalOkttVGibEYHgGtge3kxWS39WNqMZwekUkWDMenl7c2wla5NBA7T8nQ4A4/HCZiWRdfIWGbWmvSCXpunFlGO2vTvX9c3veJwUc70UlgEqNX1dyPwN//0rwBH/vKnPwBzcMDqq+xMjVznZT6cJuDxcAQ+f3l61iRP3e+n8/HxGVinCQidsgQGUyoxed3e+mKDBjCEnIFY8kgBxk0P8P17SYEPHuBffvp5L+5xmoAY48AAjBWgT0XjT42BHIJmAt31PXC/3dyO4+WvNScNqFLha5lmDew5TitwntN5TsCkolaqNoNaSnfVNeYzIDaUKmM6w+66IHiZZlXbc2XvOURgxT+eJuDz8wKUlNcMba4KbR68u8z3a23T8LIJt+Yzo5fF3pobXZsQZhCLGg7i0ANvf/ih7wJQDntgWSbN4JnLAuyPx4enZ+Dzl0dgf5yiJDT7AZhOs4SU77c3wOZmt7vdAnq83d3I4QhHdMErI7QW0GWppvcagF0fP9zugPzjR6Dr459+/QI8LWpeLZ2qC6kCfawaurPpOuB+t3tzuwN2Cu5C6K1BVPWSVbQ3qzcvSddSdehUXFI7kMah1bxUp+sBZHCKkxTUdMW4UQ1Wu9gM4HA2gM3eOau6sO6PwPE0m1SO5i16Z127EoCvNjqhcRrrJbm2jzGtRruCvAZZfw3LBkQXm3RGKzIZJ0syusV3777/EUibETj8/Oc8vSi2PHz68vnxCThqPNgwvnn7hoZzff/2jfkQq6YFzcDqexu2PFilXTe4dQwZV6G4dNaMnBWYp0nsWvXi/fD2rTqjn2ep3diwhLHvgN3N9lYp1s0O2O42WwnE6fvlbG3K4j7Os/q1mwVn5e7K96Y1n6VlJ7dS/GKFQhUMTI5CjdjRRW/cU2Nu+Ks+XU+Td2lWpzOs5DB6r+xx7KWMajp4GrpTSzHljAsJy1gTwufbezbg7JX4/lexYkuWzXOH9m/9uMzW9t9puNVmBea+98vCRQbTxfvtLfDmzQdgvNlttyOg7g+fixoxJvGfc9FGokL3Zhh2/QD0sXGqX/rkoHhFBqlNGT0eTrQCUXDu/c0OeH9vPY9Sg7AJ62N3o+EvkjPCGzXMlIlyFZ68zMC8LvOyAmvbg/XjeVmB4zyroU1szqVWdc7lVlY3cowAjYQ1trygSQqFjPRkqsaW0ziRwvRxQwyD2W4ANmO/20rCYQRqNbKOkPmypnqlhnph9l8U9GuTC7cCnI6vmOaUc23MNFBSEeO8niYdpLoc39xHYAwbVQSLNHhM6AAxbV1KIlgNrXApZWa1yI1d30tRRmrVuemZys8UI87Jya/LqlpvaeMerciqxkdcOp0B8UnK3kuCvd/eALEbjOkhh5kvqqci9U3Gv09G9lO3hIhpx9kaUyWskSrZutQtmjVqu9UPMjbiUMZyUcuuQDE1H2sKKcW61lX2bnwt0/+PfaeNbBw7IPq49AE4uRMw5aTyfFN64xLPARcxxlcX/Y0vs2BXbUCVa9IFZkk5A8fD6Wk+AfX0DOzq8qYfgM3NFrgdWUsGzmJf5HIR5gO8D9IB3MYIxBBtsqqNjGhqblJEdjVeIbel5tYNVYHgDKp12evY8rIA+6c98Hw4HE4HWn/wOVe6ERhu3wDb2/txc0ML/Xy12WbOhNhXCTA0nb20zCut6+m8rrM4tsKc29BAGjHLXSkiu+LNsTQp1OsJueXSyXXR30Mv9UC5NE9rG6mINazqYRjiqElv4mSlsjrBAK2EaptAi5Zd4dWCv/kVVdtyeHcleR6qz+sCKKj59OXLaf8E5OMz8MNuePvhBtBuSkmaOtw3UEwq27qFfbXow0QxfVDlStNlXFO605YRXBuYHKwFT5REWUzwXoiHbvOcihg8kjX58bvvwvb3wPN5Av7lp5//+PNn4Kdn7cSHu/t3wO3tHdB30RlfXHaciukWC6HLxrxXg0kui9CJRuEu1/T0Rjqz5UyM86Wq4x0tD6RpfF8gC4HVTYfLqRVYjCgfbOxhH0VViBdFU6CLXVqKzgNQqylrviwhWba9O9cZE1/eL3366Rfgz3/8M7B/fhTrbH7+Agxv7364ewOMvVqbfR8BpOORyIsIsyZ/wbVMVmlE/2zqH/56jLX3prhgx+psqo5mYVbnVHmdTUcni39/9/YN8OG77+sQge54AJ5L/cvzDDz98gWYT192UwbepQzc3myFzaku6Uyvp1V2s91Dy9dCIpLlT63/IDRnKNTACq7lqjHhqnfhWiGElsLmWvOF5QqZuuRKg0grJ1dXIAaxPsw2xDCujSN2pUf9Ep+nbCPOX130N77ipWZsjrQCPH55+NOf/gz8/NNPwPFwOB33wHJ4ArYl//bde+D+neZyOQPBNWqqKdIplyCXqqZyKToUizJM9cE5Uahy6wAuJdHS4lQ7ddMWL/k/NxWAWe/vfewHIPUR+DKdnx/PwM9PT8CfPz88qEWxqjDAMs3A8vgInMpyuxuB7dgD0XvLW8yODYU2Wbxi0xFWe069xoy8ayPAWsnh0rCrx2L8E6fHpmZlLvpSddCn68lqZa7nWQ3Kot37wna7o3HQXHDi2MrblWLS0+qCmeZZMjqvFvyNr2ghgHdy6M/7I/DTn//y5dNnYL8/AE8PD6fzEVhPB2BM69P3B+DH+7fA4GwfFWgQog9DD0iu2hVn0nPWzWY0aW9hlBO5+qTxdGnZbTTMrQeWNGyGACY1vrqQRKkJHTDlojTp86fPwOP+P/3y8AB8Ph6Bw5LPKQBr0BSETtOsjssM5ENKzMBaVDQcJCwhqa9SWVWQrx5IppBqvMnqnAVoAFyGWwncriEEo18JcLCdUgCyd87EaLRDOwsvSksOrS1FH+cMZt43RbvgeyBue6CLMW5E1rAG67RWWqNepZgyVaNH++k0AX/6lz8Av/z8s4Sjj6rsns4ibOpYc6nqXRBAP/a9ZZNyWYRuCIAJKoReB6x63OF0OlvnkkTLzk+Pj8DTw2fgZrd5++4tELpB53cpDtDjKdX9WoD9tAKP+8P+dAKejxbqHzRvUoXtMIixpS3ABW+JqRNguR7OK22SRh/GLmoStzy203ajnCKvTiOCXENR3TVV1TleclxcMTBSaWipDTJUK6o3kaHSRhgYRevSU2my9BnoYxx8AEQBm5Yq2ayo/oYQVMweBk2+qquPQCk94KLXzKFXF/2Nr9jTAb74w+Me+PkvPwGn4+F0fiElrWnVTSqN4fu399KzOa8LsAmXypRQdesvCTUCtQ82GapWYDqd9vs9DfWdpunh8RHQqMTb3e0w3thxwZRJR+tYBH55PHz6ImbBA/Dw9CjY+WSio7lKwzMOgA/RxBvk5nwWrN1mvzoZzXlagdWX4BcuCPk4ao5OrwHUOYoLpiGotbo2XvXSBm1hFZArTQjM0Gb3lRM2sfwLAcMaBlsFxNjqgq+DSwRgcRYnqtlTzQChZnF+d9st4IMXHoDrARZX3MKrBX/zK3auA+ZpefjyAEznM5BSVsNgMiw0a8u8HXZA1w9iCanHcC1SPDf6Sy5FBbtcHCqhlwocj0fg4cvD4XCgwSCn0+mw39MED3KtD8/PwN41IKBWWijw5eHhizZsxQfzel7ErXeAH7chvmy6OPfSxAE++NC9KCJfDqCo0TnlJS+A6NCb7ebt27fAqLqnH9ogdlXYksDnbNzm3EZKAFRMJNPsuBSVhkzCoCmnGGaSs6xfTs5XbzQB7eLVVPvmCvA8z2pj3EjtkpwtMKrA0PfSLJAuWI+N+jLi+2G///TLLzSGw9Pj0+l4psVNyzqrF/Q8R2Bek81+zs0pGWpTgJqzNM+WdAaKX1SmVdR2OBzmeaZJQZ3OJ/3Yq2fCu9P5TPN+2T6HRWMuas7KJvsOGLyTroiJjobQmKNaXoF6aHJlgtBMczXn3C6Arpn6jnR/Hw4HxUS3t7fAOAzKYtWatSxzvXazNViVz8R3L+7XACybua0ih3PGxjKhNRPdsX7MmjSjoyXlVZm3eCxzWtUFsooS48yQNKJkHMrQZxr9w+PVovjqor/xFeWKHx4flfNM8wQ8Pj7MNnXZbrSbW3E23gAuRsU1+/ME3A6dcF1aEftaSCXXJGha+W7OudjYPgEuk2R9ZZSh7zQkRE1HrrMIpbvZAMPNbvf2Da2kPy+rOeHggTWX5TwBy1nSWsnE5WR8tS6r5B8WYFmWJoidgbIm4Vynk8ZUFbXkyiF0rVXH5oeUsl7JoFRqG+gBQK2NQwHgvDf32zaO+jK4SjLtciRGB9CeqDPpvXNewouGdzVhLIDR1ar5klUesYrYJTv2XZQDe7Xgb3zFL1++AA8PX1RHksrJtMySnhMOEGP37u1bQKHH/W5zv5Vcorrepp4eGJqYm80+Vykm1TYswYogumf1zsu6ivjeCfwKQXoMut+j974JtAMOd1OhicgtTRdO8cvxdD5r0kM6AGtaTevd5jOn5qJmYE3JtMW1Ja+r9mY5jM3mZrtTONmhuX86WZIU96608cYgjSlzXcCl4u5etJUcTTj0Uu+3AXf1MsrPuGDag40+VbIJNrsCBG/cdTE+acBLdAqmUjQSWAV8zeK0x8+fPwGH/cE8pxK+ah5HwfPbt28kJi95z+9+/M3f/fA9UE4H4PDzn3XGLdEsVeB56660IbDFssZiCvzqhKxFNDPzgbWs0idoNVTLFotxJIyA6+0cCZYT9+q4P0wnSb+fgdPprM7MNtajTdkW9O+8xhBgfqwTCXAcR+DN23fv37+nwU+lDbaUdy01a1upjThWrv5Kq3xbiBeD1e9W46wQXDsKtYe/7BS1lHZ3XB4EMAD0sVMRXbL0qRZpNQrsxBulQ9ZVSpG3f3XR3/iKT4/PwHk6a6rW8/MzkNe0mItegXHY9IOQnQG4vb1//933gF/ugHx4nr/8CsRO4btTCnRRKpHbyW0A1tL0y3nheJpWZ6olmaSIwhYrNcroU0rCv+Tz1zUpYlKWPJ3Pq004kLnbKAX5nnG7nRb1K+/1WlFQlXf1o6l3CRW6ub0dhoGWy83rrARJpNqUcrnyyTnXNpIawHvvr5SYL7OzG8vMtFHMgXv/VWbn3LX1xxg6a552wDCMeu6aF72hdq5oItKhmuhOAoJT2+KrBX/rKyro2D/v//KXPwOCmda1MZCNHmJxhCzmNM1S4XWzCWPJdNT0F0NocqOWVJTrGcjtxi9tO7VB0a3hwuZ/rguQ15zSi/L6uqzpesT7mmrDcAFKlXrem7sd4INXJqaB69vt9suT+SogFxPX1g7Zx6gquiK+S/aivKiuq6IqBYa50UYvPkmn0nQlvUVVrk01boyttrlaldE4l/qIFodaUqdorutNf2/ojEqQbc7jCnjnYvC0JqAYvVcY6yoQvFNIFM+nFTid5ufn/eWK1nZV7m9uge04KtqRX/2yf/rnP/4ByM+PwPr4fGN5mvHKgk1HzUCuOfMirHHxySb8V41KoZjrPE+6Kud5Ao77Q9sjRj12Fgp1QNwF9SaJhHbYH3Thh37Uqdwfj5eb43w+W/9qdcAQojhUpglrI4jarG3nnaGtplatFMC6ObMl+saB8l8pkGmyJZeqhmsMj8b7N+ccLBQy4VaN83Fe38UoeYUSXzDR2uRPhUEGyrJGYJ47oCOqm/IyGCqauPfr+qZXPJ1mYL8/SbdNkPk6r8LTP373HfDu/t39u3fA9u4OKKH+y5/+ACxfHoDf3t68e/8O8PMElGWRTzIGrg9VMFfMgK/FX0+WaKIkkrE5nWfhXwLUToe9gLaP330P3P/u/u2bt7ykp97aQ1pMczpMXBDiUpVUTRK3av2DxqzwDdY3h1J9O1rEu7CkrgJryhYnamvImSvpq5dpGBYuXYocANUZsOVa45CETEOjGP9nAwe/jshKKp4W67lkuioSeCAtymmPOttsu52kjyTR0uCw/9I74XX917liQyGK9jOVz9Z5tRrIuAHG7e7v//4fgd/8/nfA83H/f/2H/x04rD8Dw2Zz9+YtcPr8CZhOx2gFHGX6NpTEqdjibbCnxikv62oVMambHk+6W5WV3d7eWuxzacZzBtLq6FWJUka/rovsLC1mZ4tNTZBM+VovisW86Fxq+eCVbHTmV4w0YxOI07pejY7IOder116Op7X78LUo6IUnXYGCDR9q6lWhXoWcPrivgA7rgbmUnlbN59qIhhCDKzalEZi7rrgtWC9eziYSaGT5t2/f3799Q2OzTh/OswrDBeC4rOq6VOK12Wzv7+6BJ7FWSzmLoqVJisva2ZQMQVTO0jXBjSF0Qweotfk8zULBYtYvB8Wi961Op+BLfK7pdP6UEqCRZkM/6DTZFJ+UeCE6sa6rQkJdlVpLC2sdcpjiapkSbrRiaouim+C/1S3SxTnbldMVtdrtfzZyjCbHoVukXX5Qd64917dHKzMAPkR/1X5wdRhSTlyDr0DtbTyUT14XHlhLUf4v0biSVt3Zry76G18xhA64uem7sQM2uw0QYtwfnoHj8x54Ouz/5//lfwX+n3/+Z6Dvw3Q8AGrBe9rvP3UBcOsMTDmt2QEbVfq8qd5Wq7u7zkVAFtMPQy+SpYad+tCPIxfdhWGU1z2ICbvfy1mleQWC8/LkWnlNixUhit7QiucKpry/ylPx7lLOc0AXo7pCLGdtQdYl7S7XNfzmjYX6Xn7ZCvwWKhljJGdflBcpe7F3rsEBIQYdVS2qP15myxlRq3ULJPuO+SVp7n1oWTtAwomxJXJEXqZSXi34r2BFa3yoVdLv1XeA74ebe+3kA7B/fJApixDpvDXkC/54KCnkFbjplQBY+VpYtMs1tDoWRgdXomL2jRuBLllNadhsgO0wYqGWMV2A6LyyptL0TbTNFM1AaRNTrUqYi7PJzAJ6QvCXbU9wg0wKxO5xV0WeYiMUk6Ho+VIK1FlrCZJ+cvqjJvPU6l9sGqiIcG/Nm1/rsscQFJC2SlRtCJcQ+DXXlVYuhGrjhVbJwFvc4IhAqlVSmmo/IK3bodMFVgjgpS1gNLZYutjT9A/GZOR+dRLUWrz1mgIUZ+FVLx6298ou1RVel9ppMniwqlaLJ60CKCfZukZDG+Gq9zfg3o8j0Me4bDY02CulJJxPZKgYfcpGAQe8EwUPCU8H3yDDy/m9Qvmdt6uyGi+1QaTGkLrUAXX5+eoSvsRT+im3kEt30kXP2SKvfPX64H3X91zajS4VySLaXraSsymrZWuE9w5IpUqyVnHxmpIOXtIUt2P39v1HXl30N7+i6bPFiInU6pIHcaMkUeOpSJ7hfALIRV6p12g/ktRwdQfn1qzRyuMqtREDQIghmAiN3Vst8VP20uaafo3shGbf8rfKVtd1Xb3SGCXc0bmkQwdq63n0Ly5BzArja5ZWn9dKNgKs9fk0P68jbANrLhntCzfq0j94AbKuE99a2wyxxr3KVzJCrmnZDf3Ai/qhrYqhYAInSrPg1kBUpC5s/TW5iAhgo63v7sXOeLXgb3zFf3g7Ar+e5ikBuNgBo/c7TYzabYBls9UOvZYvQJ4n71X7sy3Kii3S1axVW5epjvpWEFShppSAibNg9XDd8x7wtbVh2bzoZNpEDdkR/qVKkPM2giqlCHS19JrInoQ1OAO8Gv6QreQnCSYjlbdkpqiYL2hsSWvDNOw0fT1GrmHFuTXYX1X4L+uidOfqyzvkNlLwgjlrQ43RAzWXJuBycW+KuexH+Td5gGld9F4ShK4py63GzRaIfSdqQ/zv/tVH4D/++fPnuQLhZgT6m914swH63Q44LpvTtAD70wykSskzF9ZZdaZfrhDUWRStE1o9sVOnqDQTjQTqTZhalQgr12WXl6SBHhXIZLFELkU0dwUKhhB0W4Qmt2on0arDtcU+pvfQohvtJEVFTN2L65JFxT1PRspvtb92NcwlNzdbXmLsqo7RSw59aTqykM4GJSmoLNm3AUpigxS5XwVK7iJsZi8xaVoNffbOmpYW20dWjRSxONwVcSB16yzzOS0Try76m1/x3/3dB+BvfvNxL32+aLv9JF4VC7CPlC3AMgAcspM5uuSBWKzkrZHzizeVLZtNUd3gJHci/nfTOdVqXMDmDHIy1QS989DnFy5YjEHlPGeN2JYft2nVhpapVl+yKfU2o6j1ir+YW6Zrjc7nWZR3YWGXCqCRraxMZ8FOujiDasbYrMTiw2t6unNct7m4djhCHVIq1ym1c+6ruoVvR9/AODmwdAkP5Zx9BFzAi5NlqoBJmferBX/jK97cRGATesktaXDJtH9exFbpBmDqt+NdBeLeAV8I61Jp+uhrroqJBJhWH5S2+6bpnk1yvALBOUl+izGErxr/QBPHu+6+8nO2Cl0pwDD0vSSBTXXyUqGzpKoBxtre0mpcTOVFKV/xuaY2b1FE/9P5rFadYpGBbzIrYOmKaj4iQlsF0F3UKItFDFi5v9mfraua/gUsE+crF6NQWQt1sQ4Xb7GFKJIX+65Xou3BRedeMlvnO4dExACmJfcK32qeAbecOR2AcngEwnS8G3vAj/dA2XZ3m3vgt+9ugfOUNXleDYOfvzzsz5plkYDzvIh6bxykYCKJGOxic8uu4hbfvhHVtSgzWZiq4faK13LK+kdv6E9stT8D93N+QaOWxYq4duPm3Lqh7IqqkdDm1S5Ltr5NgFyLCee0wRpfkbD+fwVg09H56jpesuSLsKz9uth2ZhdYN40VE0O0ZvnWueSueFWVajPP7X4OqkFI6SzihAibfqwPr71JfxUrTk8PwPl5v572QMcKjGMQwuJDBpxbN9sbQCMTyprkyedTAJ7uojQGJAJympZn9ZJME3A8zU/HBJxWswbD5i1pqZfxpxhILaNUFJPllKT4Xqsl3IKZuq5rHT4AtVgTlIqYy5IEThkrIxcxH85Ha2wx7eUmyvcS10AulspbE3cTq7OP8xZGldYn6K4cycWsazN3Q70Nk2rSDsohy1WufRVGiYgZQrB2GycyZdGTg6Kq6iQcXS3RctVYtB2w7eOme+0P/itY8enXT8B8nnR7bu7ugX7Xu+4i/k5d51qeAOoecGmJ6wqEXIFhG6KmC9/cADlX6ZcfJ/XCHD89zsCnYwL2x9PpfALOZ9spTX2otWS10k0GXLHkvdpG5ZrCQUOVrcZnO7TptWs0zrIKtFJUtaasvXlunYkKDC9pihXkRKRvZRzbdC/ZS6McuytGpru0QF61jHGxzOaYLmN1bGZKI/1cGoX1ErN7Ex2NGtc1W0SSW8NLAFytGutaNR0shtthAD7cbYDdOKR1AmJezsDN3W232QHDbgs4l03JWNhKSnU9XQ7alazWYzmu4AdXF8AtRyCGEHwCNn0F3r/f/vbdHbBfHfDl+fjrp8/AL79+Bh6eZ/G5lnNGAflVocJTa22oDQQXxJmSdIZ33gKKahSORaL9RqSyC7yYVv/aktdq58gYt9XuptaCredcC8h679pUZ4Wvpo6vySHe2QW+Gk+tS3j5sbZTBd6qKS+liauqZa1VwZ1C6eBdFj8+AeRaWyeTELsSSwHu+gD88Gb32/dvgDe7DTBPp8fDM68u+ptf8e7NLdBtb3y3BcK4AVgXFRIMKF9MEN1yhVqzgSlqhbMRVNaQnDLzBEbRcs5pcE6/2QD3u91v3o/A6fffAYd5/fXzE/Avf/gL8OuXp/QSgVFqVuk7GtgbrIquX3ZBcl2xik4Vope596hBVr3VszUztjYnKznYkAYlQq0DWD2VLl348M1FXznSGKOGeRl/qlQbq9Pc7LWEA3CVOb3UEm0Ub7383vYawW2tx7Ch7OXy/g6aZCR1Exzw/nYH/O77Dz+82QF10cy2p21XeLXgb37Fzf07wMde8LKqeKXhS3nOQJkWzQDW8JHifb8ZgVHaR+OgskZVJS6tTr2/MkZ3qe9koAuhbzxO4P3N9u04AmFZAb+sQqGTcqemR5esIXhVaaZN2rJuWlGHYoguZKArBlmIaWBaFCkpBLNQa17EmpYUSy7WlxwsLktfyQFc9JJFhQxdF15aZkpuM95de4k6Ml1LsbCDxSy10qCS4FSkB4slLWz0QcZn+Vi2l3jJxmvr3TjebXvghzc3wJuxk+2enr4At3348JvfAdHf3AKuKRfL26TpfHp+Ap6+fAGW00ndpOJpbm5uunGkTTYMMZRpAvL5jNoa5Yrs+14kz3WZiyrDphcdeLMdge/fvwEePj88ncWf9UB2oV7cPkQfhGGN3ah7sTTWhE6htxl/dkI19/AicmN+r8131O9DssJfkHNW54QzRREbNe5cq147fV9tGVrZOv/a9IFarDJo37pyRTK8kO6siFiL6LS+qeKb6G3rGnem72rvIJc9Bg/cDvHtzQa42/SAL2meDmADsb//8PG9GsZ4Xd/0ilUy7cfTJOXg4wk4fv4kC358+Aysadne3ADfv/0RuH3/pt9suRSoT1M6T0CZFiCHIPUb0znAXKgvHYDzomEUVmBKk0Z6apLGqaTH4x7QBOa5gcCiWt5tb3e7LSCUrVKEzZbW9lPdFf2jtiFf8uLea2biZTVzVHrm/Aog5VLnilJ8fbprjMxgw7RtdoIljak1VVsTSmm5rD7Ft6S28VAF1RlFy6lr+1KebNQQJfpF8ZSyYR98lCTs0AG329GalJx2okWb4Ju7G+D27q7rxKd7Xd/0is+/fgaOnz8//PIL8PjpE3A4Pgu1GccBePPdd++++wC8e/8BuLm9VxK/Ph+Q0ML0gnvMOR/XBThZvd3RRTBt0iUX8ZU1BeHz0/7L/gicpJF5PH95fAI0JH5dl91mA/zw8Ttgsxs3m4G2j5ZsvB+jHjoz2dLKVFZKVEEmhFhfAIfajMVncQRs65ZcOJRsct4AIbRRQNH4Q96pg89Q5ZbsWERGa34EnPPWChwurAR9QgVcujBQZdDV4BebVlekIi8J+YjrJOM1RGDovG8+Ayhk0bvUmeejFRPjf/r3/ydwfHyaTzqnq87gZrsDPv7mN8APv//99vaGJvBwnpK6g9JhBuqcp0kE/ABMpT5NE/DpeASO65pDDxznAhyO58laETPwcNjvTxOYRGz1Xtyo5XwENqG+e/MG+PjxA3B/fxtV+1RJVcw/rDDpalP6sznJfMXA9dbFqtHT1XuRAu16Oh8lLyV+U/DOiXtbga71Hqpq61orw2W0d/Oreu1FnUMbRPiKseUa4GX9B8aDtxbvigA2aWBkXJsPd7nA6B9ASVkCD204ggVose8B56MCw1cX/Y2v+OkPfwHOp7OaU3a3t8APv/vbj7/7HbB98wYI4yD5uOfHA/Dw9HTYH2n3LNVPs0r9CTis635dgSfNhF3TKSmMsmLD4XRCZAYI/TButmCTaabzpBrAJg7AD9+9+6d/+Efgo3TnnKur3ekoYLHPFxTsvXtxwqVY75+BUt6poQ+zVPv+jd5lnA3FVnRWPDfoKnRmu210hqX4NqmiZbrevL1sVRz9EKPJ+vrWA6apDJqDuKxNsCfpIBWLmQifc6YRYymsMUna5J1cpKlvUaUPQwf4bgSqCzrGVwv+xlfUiNx+e3P34Tvg+9/9LXD37p3o43/59QA8Hn56en4GTqcJ2J8mKRQJ/Ep4baiaODfnOq0JmJYETCnvzwtwmBauxMT7YQRuhp2GuZ2Pe2CdTprT9/6HD8A//P533394C2y6DkjLeqnBoMDEv5TtLjoP+tF7R9NNB6ityIjuepvuo3IN2WO7uwdy6Os13hTCddGnlFp8ApxYaI1FaTuxdxqwaANc+u5amHspuWYZnLWgWduL80AXfGhNMvpC0fqJZLMWGVowEW169nlNgB+D63tsjCtrLl5lxI//9K+A29s3ruuBKXTA0+fnn3/6Ffjl0xfg8/N+vyxAweLhaX1h2c2uasT92nxVUl1W8y7WpDk6UuEIXbfd3QDjuAFqypr7Me2fgI705sM74O+//w74zfv3o6YerQkIxUJfc8LOfHRt48OsAnIpy75oKmhGpkIkO8piyJqeUtXNXZWk2nAji1+8D9exLrX4CyfWbp6XwoL3TjXNQWKvfW8oGABdWUt90eFvfeUETYR2URmwsFhXLdoSQTH0vWJbG/sYO33us6Z2u37YjsCcAbqUbSQJr+ubXnH88CNwSuWXXz4DP396APaH05fDBOwX4U1ltSJ2AMimlJO8A9Zap5yARbhSrlKEE3yd1rWYBrIHxmGz2+5onnN/3M+nA1CzccF+8/Ed8JsPb4GbYdBMnMZxNKMprUXnMmEDXn64cBCvbBnXwKJyKb1ZMmPgsw20lRZFNp8ZTfXBt6YYlQTWBlqZFdaWiQE+hM6EWy8W7C/fl2RvYrtJy4h6aYe5YILJZqNeaaHN2ei6sxPtQluDTYI3BeynRQnSMOyA3ju1Gb5a8De+4n/4Tz8Df/n5118+faYhSqvzcwGYqwMK3ib4KiLIpoNXkgNSqWrmF0iyLouK6u0GL8qmhn4LbMediNCnZQLmktU4rA1xd7v77uNbYCdF+Wq2a2RxXLkwbNTlBlzyBFqaZMUlrrkyhWpl8zbZ3TV8BFMFB/AavdPm4F0ERfV9FXOkVCVBJcHxbGN0bPhqPwzjZqCJp3dd1ya2yBeVpBBJ5PVqoWFTT2qMohiAru90AH1nXdHC89dVnX9rLpGWcJ6XOT4egM14A4zddhc6IP5P/9t/AKY1p0byBhaKTbvGA4mKHUHDxA32axwG66q2ToK1ac4DIYQh9sB2uwWGYWPTllICfPC1vOAvb9/c393f0riftdSLXrsukuWcF4zKXSgSmKsF157ULrW5xFZUBBNqfnGzZCuXGuO8dYvTfvQme2N0EyPsGbU26bQYX3UcN+NAkxG6KELXlpX6l31D31DFBqFvppMVG2fd2p8MyMxN290jVuE803hkpZSn/QG4uTkAt5tt2m14ddHf/IpfjM54UT0GOTSFM/qxms5LbcMxms8ESNk05TRBIWVTR/DB9LDUG6hHvF+vBOBDiJJz6r0NotqOGy6ob3UX1gBwCZuuuE1c/uFcmwl6ySSvBLq8a7VEGWUu5ugljWNSOJdE0zVVUgOwrlm0tVpDUbO2aFzPcQSGvtcMrAv4ZSlWU6Voqgxy70ln0WDkGF4+AnIxlPvCiLFuR/P5mfKyG5XqBDx8fngCbsbtx3dveLXgb37FSZUvd6l5AThXL/srCAi4kjRoW1TTQbeesNb33lQhDYztVB/MrS6tp9mkgeByWYAxbICbzVYA0BURHK5uf3cFKdD6ulx7TtbtWi5/r1xq6WAc0EZNukRo+sLlMhwYvAvmfppccV2vwCrqtZyR781FyYK7GJsqgRnPlXQLzhnHW011S1r0e3uJt3EXFztu/YwJKFST+lLkW6o+oosdsKyLmpufDyfg6XAQvBhXjPFwdX2F7Oitr6/7Sxtd68KraHDOlfBfqU112VujXL30HcGarZVByWIXnHT67m9G4P7ubuzFQ9BLamM22WUw52zy7O7KT+NfEK5Web2KomutrRMbDIPUW2kvKOXKgQcfXXhx0bVWl14uUtsELBSKIegCD/aNTKDooujQLpKuSlYMbFOF0to2smDn9yqqQqI8kE11pJa2Kdih6DzLJEpVB9cyLcDD8/HxcObVRX/z6/8Dyyi+a8E/pakAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=160x160 at 0x7F858E0C7F90>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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",
    "<a name='ex-2'></a>\n",
    "### Exercise 2 - verify\n",
    "\n",
    "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",
    "\n",
    "- Compute the encoding of the image from `image_path`.\n",
    "- Compute the distance between this encoding and the encoding of the identity image stored in the database.\n",
    "- Open the door if the distance is less than 0.7, else do not open it.\n",
    "\n",
    "As presented above, you should use the L2 distance `np.linalg.norm`.\n",
    "\n",
    "**Note**: In this implementation, compare the L2 distance, not the square of the L2 distance, to the threshold 0.7.\n",
    "\n",
    "*Hints*:\n",
    "\n",
    "- `identity` is a string that is also a key in the database dictionary.\n",
    "- `img_to_encoding` has two parameters: the image_path and model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-ba2f317e79e15a2f",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# UNQ_C2(UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# 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 an employee who works in the office.\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",
    "    ### START CODE HERE\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",
    "    # Step 2: Compute distance with identity's image (≈ 1 line)\n",
    "    dist = np.linalg.norm(database[identity] - encoding)\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 in!\")\n",
    "        door_open = True\n",
    "    else:\n",
    "        print(\"It's not \" + str(identity) + \", please go away\")\n",
    "        door_open = False\n",
    "    ### END CODE HERE        \n",
    "    return dist, door_open"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Younes is trying to enter the office 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": 19,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-014d077254ad7d52",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's younes, welcome in!\n",
      "( 0.5992949 , True )\n"
     ]
    }
   ],
   "source": [
    "### YOU CANNOT EDIT THIS CELL\n",
    "\n",
    "# BEGIN UNIT TEST\n",
    "distance, door_open_flag = verify(\"images/camera_0.jpg\", \"younes\", database, FRmodel)\n",
    "assert np.isclose(distance, 0.5992949), \"Distance not as expected\"\n",
    "assert isinstance(door_open_flag, bool), \"Door open flag should be a boolean\"\n",
    "print(\"(\", distance, \",\", door_open_flag, \")\")\n",
    "# END UNIT TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "            <b>It's younes, welcome in!</b>\n",
    "        </td>\n",
    "        <td>\n",
    "           (0.5992949, True)\n",
    "        </td>\n",
    "    </tr>\n",
    "    </table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Benoit, who does not work in the office, stole Kian's ID card and tried to enter the office. Naughty Benoit! The camera took a picture of Benoit (\"images/camera_2.jpg). \n",
    "\n",
    "<img src=\"images/camera_2.jpg\" style=\"width:100px;height:100px;\">\n",
    "\n",
    "Run the verification algorithm to check if Benoit can enter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's not kian, please go away\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1.0259346, False)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### YOU CANNOT EDIT THIS CELL\n",
    "\n",
    "verify(\"images/camera_2.jpg\", \"kian\", database, FRmodel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "            <b>It's not kian, please go away</b>\n",
    "        </td>\n",
    "        <td>\n",
    "           (1.0259346, False)\n",
    "        </td>\n",
    "    </tr>\n",
    "    </table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='5-2'></a>\n",
    "### 5.2 - Face Recognition\n",
    "\n",
    "Your face verification system is mostly working. But since Kian got his ID card stolen, when he came back to the office the next day he couldn't get in!\n",
    "\n",
    "To solve this, 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 building, and the 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, you will no longer get a person's name as one of the inputs.\n",
    "\n",
    "<a name='ex-3'></a>\n",
    "### Exercise 3 - who_is_it\n",
    "\n",
    "Implement `who_is_it()` with the following steps:\n",
    "\n",
    "- Compute the target encoding of the image from `image_path`\n",
    "- 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). This helps you keep track of 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 the L2 distance between the target \"encoding\" and the current \"encoding\" from the database. If this distance is less than the min_dist, then set min_dist to dist, and identity to name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-a04ff2b5fd1186f8",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# UNQ_C3(UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
    "# GRADED FUNCTION: who_is_it\n",
    "\n",
    "def who_is_it(image_path, database, model):\n",
    "    \"\"\"\n",
    "    Implements face recognition for the office 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 db_enc 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",
    "    ### 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": 22,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": true,
     "grade_id": "cell-9c88c8ab87677503",
     "locked": true,
     "points": 1,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "it's younes, the distance is 0.5992949\n",
      "it's younes, the distance is 0.5992949\n",
      "it's younes, the distance is 0.0\n"
     ]
    }
   ],
   "source": [
    "### YOU CANNOT EDIT THIS CELL\n",
    "\n",
    "# BEGIN UNIT TEST\n",
    "# Test 1 with Younes pictures \n",
    "who_is_it(\"images/camera_0.jpg\", database, FRmodel)\n",
    "\n",
    "# Test 2 with Younes pictures \n",
    "test1 = who_is_it(\"images/camera_0.jpg\", database, FRmodel)\n",
    "assert np.isclose(test1[0], 0.5992946)\n",
    "assert test1[1] == 'younes'\n",
    "\n",
    "# Test 3 with Younes pictures \n",
    "test2 = who_is_it(\"images/younes.jpg\", database, FRmodel)\n",
    "assert np.isclose(test2[0], 0.0)\n",
    "assert test2[1] == 'younes'\n",
    "# END UNIT TEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "            <b>it's younes, the distance is</b> 0.5992949<br>\n",
    "            <b>it's younes, the distance is</b> 0.5992949<br>\n",
    "            <b>it's younes, the distance is</b> 0.0<br>\n",
    "        </td>\n",
    "    </tr>\n",
    "    </table>\n",
    "\n",
    "You can change \"camera_0.jpg\" (picture of Younes) to \"camera_1.jpg\" (picture of Bertrand) and see the result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Congratulations**! \n",
    "You've completed this assignment, and your face recognition system is working well! It not only lets in authorized persons, but now 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, and can describe the difference between face recognition and face verification. Here's a quick recap of what you've accomplished: \n",
    "\n",
    "- Posed face recognition as a binary classification problem\n",
    "- Implemented one-shot learning for a face recognition problem\n",
    "- Applied the triplet loss function to learn a network's parameters in the context of face recognition\n",
    "- Mapped face images into 128-dimensional encodings using a pretrained model\n",
    "- Performed face verification and face recognition with these encodings\n",
    "\n",
    "Great work! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "    \n",
    "**What you should remember**:\n",
    "\n",
    "- Face verification solves an easier 1:1 matching problem; face recognition addresses a harder 1:K matching problem.\n",
    "    \n",
    "- Triplet loss is an effective loss function for training a neural network to learn an encoding of a face image.\n",
    "    \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": [
    "**Ways to improve your facial recognition model**:\n",
    "\n",
    "Although you won't implement these here, here are some ways to further improve the algorithm:\n",
    "\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 increase accuracy.\n",
    "\n",
    "- Crop the images to contain just 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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='6'></a>\n",
    "## 6 - References\n",
    "1. Florian Schroff, Dmitry Kalenichenko, James Philbin (2015). [FaceNet: A Unified Embedding for Face Recognition and Clustering](https://arxiv.org/pdf/1503.03832.pdf)\n",
    "\n",
    "2. 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",
    "\n",
    "3. This implementation also took a lot of inspiration from the official FaceNet github repository: https://github.com/davidsandberg/facenet\n",
    "\n",
    "4. Further inspiration was found here: https://machinelearningmastery.com/how-to-develop-a-face-recognition-system-using-facenet-in-keras-and-an-svm-classifier/\n",
    "\n",
    "5. And here: https://github.com/nyoki-mtl/keras-facenet/blob/master/notebook/tf_to_keras.ipynb"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}