assignment2/CSI5139_Assignment2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.5.2\r\n"
     ]
    }
   ],
   "source": [
    "!python3 --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# content\n",
    "\n",
    "[1. Getting Started](#getting_started)\n",
    "\n",
    "- [1.1 Preparing data set](#preparing_data_set)\n",
    "\n",
    "- [1.2 Select and Plot image samples](#select_and_plot_image_samples)\n",
    "\n",
    "[2. Template Matching](#template_matching)\n",
    "   \n",
    "- [2.1 Compare different matching algorithms](#compare_different_matching_algorithms)\n",
    "\n",
    "- [2.2. Classifier and Validate the results](#classifier_and_validate_the_results)\n",
    "\n",
    "[3. Perceptron](#perceptron)\n",
    "\n",
    "[4. Classification Comparison](#classification_comparison)\n",
    "\n",
    "[5. Feature Engineering](#Feature_engineering)\n",
    "\n",
    "- [5.1 Feature Extraction](#feature_extraction)\n",
    "\n",
    "- [5.2 Train on new data](#train_on_new_data)\n",
    "\n",
    "- [5.3 Results and Conclusion](#results_and_conclusion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='getting_started'></a>\n",
    "\n",
    "# 1. Getting Started\n",
    "\n",
    "<a id='preparing_data_set'></a>\n",
    "\n",
    "## 1.1 Preparing data sets\n",
    "\n",
    "First of all, before showing some image samples, all images from all subsets are read and labeled into different data sets.\n",
    "\n",
    "The general process of creating the data sets could be described as,\n",
    "1. Get all image pathes from subset 1 to 10 as all training and validation set, get all images from subset 31 to subset 40 as test set;\n",
    "2. Loop over each image to pair it with the rest of other images;\n",
    "3. Find the subset name of each pair images. If two images have the same subset name, define them as the pair showing the same face;\n",
    "4. Label the image pair $1$ for showing the same face, $0$ for showing different faces;\n",
    "5. Save the data set as format: '[str(image_path_one), str(image_path_two), int(label)]'\n",
    "6. Separate each data set to the same face set and different faces set;\n",
    "7. Create the training set and validation set from sub1to10, which have same portion of image pairs showing same face;\n",
    "8. Print out sizes of all the sets for visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------- dataset used for training and validation ----------------------\n",
      "The orginal set conatains totally \t 105570 \t pairs of images, \n",
      "with \t\t\t\t\t 10350 \t\t pairs showing same faces \n",
      "and \t\t\t\t\t 95220 \t\t pairs showing different faces.\n",
      "---------------------------------- dataset used for test ---------------------------------\n",
      "The test set conatains totally \t\t 73536 \t\t pairs of images, \n",
      "with \t\t\t\t\t 8448 \t\t pairs showing same faces \n",
      "and \t\t\t\t\t 65088 \t\t pairs showing different faces.\n",
      "----------------------------- training set and validation set ----------------------------\n",
      "After separation, the training set contains \t 104515 \t pairs of images,        \n",
      "and validation set contrains \t\t\t 1055 \t\t pairs of images.\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "import os\n",
    "import random\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "\n",
    "# define all the sub names, session names, and frame names into np.array\n",
    "sub_names_train = np.arange(1, 11)\n",
    "sub_names_test = np.concatenate([np.arange(31, 39), np.array([40])], axis = -1)\n",
    "session_names = np.arange(1, 3)\n",
    "frame_names_train = np.arange(1, 24)\n",
    "frame_names_test = np.arange(1, 25)\n",
    "\n",
    "def GetImagePath(sub, sess, frame):\n",
    "    \"\"\"\n",
    "    Function: \n",
    "        Get image path name according to the inputs.\n",
    "    \"\"\"\n",
    "    # read the image path\n",
    "    folder_name = \"sub\" + str(sub) + \"_session\" + str(sess)\n",
    "    image_path = folder_name + \"/\" + folder_name + \"_frame\" + str(frame) + \".png\"\n",
    "    return image_path\n",
    "\n",
    "def GetAllImagePathes(sub_names, session_names, frame_names):\n",
    "    \"\"\"\n",
    "    Function: \n",
    "        get all image pathes from the specific subsets.\n",
    "    \"\"\"\n",
    "    # subset 35 and subset 37 have no session 2\n",
    "    sub_no_sess2_test = np.array([35, 37])\n",
    "    # store pathes\n",
    "    all_images_pathes = []\n",
    "    for i in range(len(sub_names)):\n",
    "        sub = sub_names[i]\n",
    "        if sub in sub_no_sess2_test:\n",
    "            sess_len = len(session_names) - 1\n",
    "        else:\n",
    "            sess_len = len(session_names)\n",
    "        for j in range(sess_len):\n",
    "            sess = session_names[j]\n",
    "            for k in range(len(frame_names)):\n",
    "                frame = frame_names[k]\n",
    "                image_path = GetImagePath(sub, sess, frame)\n",
    "                all_images_pathes.append(image_path)    \n",
    "    return all_images_pathes\n",
    "\n",
    "def AnotatePairs(img1_path, img2_path):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Get the annotation of the test set.\n",
    "    Principle:\n",
    "        If two images belong to the same subset, they are showing the same face.\n",
    "    \"\"\"\n",
    "    # find the subset number\n",
    "    img1_sub_ind = re.search(r'\\d+', img1_path).group()\n",
    "    img2_sub_ind = re.search(r'\\d+', img2_path).group()\n",
    "    # compare subset number\n",
    "    if img1_sub_ind == img2_sub_ind:\n",
    "        label = 1\n",
    "    else:\n",
    "        label = 0\n",
    "    return [img1_path, img2_path, label]\n",
    "    \n",
    "\n",
    "def LoopOverEachPair(all_img_path):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Loop over each pair of test images, define labels.\n",
    "    \"\"\"\n",
    "    data = []\n",
    "    while len(all_img_path) > 0:\n",
    "        current_image_path = all_img_path[0]\n",
    "        all_img_path.remove(current_image_path)\n",
    "        for another_img_path in all_img_path:\n",
    "            current_data = AnotatePairs(current_image_path, another_img_path)\n",
    "            data.append(current_data)\n",
    "    return data\n",
    "\n",
    "def CreateDatasetFile(sub_names, session_names, frame_names_test):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Create the test set file.\n",
    "    \"\"\"\n",
    "    # get all images pathes\n",
    "    all_img_path = GetAllImagePathes(sub_names, session_names, frame_names_test)\n",
    "    # get dataset and save it into a data.txt file\n",
    "    dataset = LoopOverEachPair(all_img_path)\n",
    "    return dataset\n",
    "\n",
    "def SeparateSet(dataset):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Separate the whole dataset into sameface set and differentface set.\n",
    "    \"\"\"\n",
    "    same_face_set = []\n",
    "    diff_face_set = []\n",
    "    for i in range(len(dataset)):\n",
    "        if dataset[i][2] == 1:\n",
    "            same_face_set.append(dataset[i])\n",
    "        else:\n",
    "            diff_face_set.append(dataset[i])\n",
    "    return same_face_set, diff_face_set\n",
    "\n",
    "def GetTrainAndValidationSet(same_set, diff_set, portion = 0.01):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Separate the whole set into training set and validation set which contain\n",
    "    same portion of same face images and different faces images.\n",
    "    \"\"\"\n",
    "    random.shuffle(same_set)\n",
    "    random.shuffle(diff_set)\n",
    "    num_valid_same = int(len(same_set) * portion)\n",
    "    num_valid_diff = int(len(diff_set) * portion)\n",
    "    validation_set = same_set[:num_valid_same] + diff_set[:num_valid_diff]\n",
    "    train_set = same_set[num_valid_same:] + diff_set[num_valid_diff:]\n",
    "    random.shuffle(validation_set)\n",
    "    random.shuffle(train_set)\n",
    "    return train_set, validation_set\n",
    "    \n",
    "training_set = CreateDatasetFile(sub_names_train, session_names, frame_names_train)\n",
    "test_set = CreateDatasetFile(sub_names_test, session_names, frame_names_test)\n",
    "\n",
    "training_same_set, training_diff_set = SeparateSet(training_set)\n",
    "test_same_set, test_diff_set = SeparateSet(test_set)\n",
    "\n",
    "print(\"-------------------------- dataset used for training and validation ----------------------\")\n",
    "print(\"The orginal set conatains totally \\t\", len(training_set), \"\\t pairs of images, \\nwith \\t\\t\\t\\t\\t\", \\\n",
    "      len(training_same_set), \"\\t\\t pairs showing same faces \\nand \\t\\t\\t\\t\\t\", \\\n",
    "      len(training_diff_set), \"\\t\\t pairs showing different faces.\")\n",
    "\n",
    "print(\"---------------------------------- dataset used for test ---------------------------------\")\n",
    "print(\"The test set conatains totally \\t\\t\", len(test_set), \"\\t\\t pairs of images, \\nwith \\t\\t\\t\\t\\t\", \\\n",
    "      len(test_same_set), \"\\t\\t pairs showing same faces \\nand \\t\\t\\t\\t\\t\", \\\n",
    "      len(test_diff_set), \"\\t\\t pairs showing different faces.\")\n",
    "\n",
    "train_set, validation_set = GetTrainAndValidationSet(training_same_set, training_diff_set)\n",
    "random.shuffle(test_set)\n",
    "\n",
    "print(\"----------------------------- training set and validation set ----------------------------\")\n",
    "print(\"After separation, the training set contains \\t\", len(train_set), \"\\t pairs of images,\\\n",
    "        \\nand validation set contrains \\t\\t\\t\", len(validation_set), \"\\t\\t pairs of images.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='select_and_plot_image_samples'></a>\n",
    "\n",
    "## 1.2 Select and Plot image samples\n",
    "\n",
    "In order to visualize what the data set looks like, a set of image samples are selected and plotted. The first row of images showing the same face but with different illuminations. The second row shows different faces with different illuminations.\n",
    "\n",
    "Also, all these image samples are used to find out the Nomalized Cross-Correlation threshold in the following session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/azhang/.local/lib/python3.5/site-packages/matplotlib/__init__.py:1038: UserWarning: Bad val \"GTKAgg\" on line #1\n",
      "\t\"backend: GTKAgg\n",
      "\"\n",
      "\tin file \"/home/azhang/.config/matplotlib/matplotlibrc\"\n",
      "\tKey backend: Unrecognized backend string 'gtkagg': valid strings are ['Qt4Cairo', 'svg', 'WebAgg', 'nbAgg', 'pgf', 'pdf', 'agg', 'Qt5Cairo', 'TkCairo', 'WX', 'template', 'MacOSX', 'GTK3Cairo', 'cairo', 'GTK3Agg', 'TkAgg', 'WXCairo', 'ps', 'WXAgg', 'Qt4Agg', 'Qt5Agg']\n",
      "  (val, error_details, msg))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image shape is: \t (64, 64, 3)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x300 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x300 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from skimage.io import imread\n",
    "from skimage.transform import resize\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def ReadImage(image_path):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Read and resize images with specific subname, session name and frame name.\n",
    "    \"\"\"\n",
    "    # read the image\n",
    "    image = imread(image_path)\n",
    "    # resize the image\n",
    "    output_size = (64, 64)\n",
    "    image = resize(image, output_size)\n",
    "    \n",
    "    return image\n",
    "\n",
    "\n",
    "# image examples, for visualization and some tests\n",
    "# same faces\n",
    "path_example_1 = GetImagePath(sub_names_train[0], session_names[0], frame_names_train[0])\n",
    "image_example_1 = ReadImage(path_example_1)\n",
    "path_example_2 = GetImagePath(sub_names_train[0], session_names[1], frame_names_train[0])\n",
    "image_example_2 = ReadImage(path_example_2)\n",
    "path_example_3 = GetImagePath(sub_names_train[0], session_names[0], frame_names_train[10])\n",
    "image_example_3 = ReadImage(path_example_3)\n",
    "path_example_4 = GetImagePath(sub_names_train[0], session_names[0], frame_names_train[22])\n",
    "image_example_4 = ReadImage(path_example_4)\n",
    "# different faces\n",
    "path_example_5 = GetImagePath(sub_names_train[1], session_names[0], frame_names_train[0])\n",
    "image_example_5 = ReadImage(path_example_5)\n",
    "path_example_6 = GetImagePath(sub_names_train[5], session_names[0], frame_names_train[5])\n",
    "image_example_6 = ReadImage(path_example_6)\n",
    "path_example_7 = GetImagePath(sub_names_test[5], session_names[0], frame_names_test[22])\n",
    "image_example_7 = ReadImage(path_example_7)\n",
    "\n",
    "# print out the shape of the image\n",
    "print(\"Image shape is: \\t\", image_example_1.shape)\n",
    "\n",
    "# same faces test\n",
    "fig = plt.figure(figsize = (12, 3))\n",
    "ax1 = fig.add_subplot(141)\n",
    "ax2 = fig.add_subplot(142)\n",
    "ax3 = fig.add_subplot(143)\n",
    "ax4 = fig.add_subplot(144)\n",
    "ax1.imshow(image_example_1)\n",
    "ax2.imshow(image_example_2)\n",
    "ax3.imshow(image_example_3)\n",
    "ax4.imshow(image_example_4)\n",
    "plt.show()\n",
    "\n",
    "# different faces test\n",
    "fig = plt.figure(figsize = (12, 3))\n",
    "ax1 = fig.add_subplot(141)\n",
    "ax2 = fig.add_subplot(142)\n",
    "ax3 = fig.add_subplot(143)\n",
    "ax4 = fig.add_subplot(144)\n",
    "ax1.imshow(image_example_1)\n",
    "ax2.imshow(image_example_5)\n",
    "ax3.imshow(image_example_6)\n",
    "ax4.imshow(image_example_7)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='template_matching'></a>\n",
    "\n",
    "# 2. Template Matching\n",
    "\n",
    "<a id='compare_different_matching_algorithms'></a>\n",
    "\n",
    "## 2.1 Compare different matching algorithms\n",
    "\n",
    "In order to find the best template matching method, I developed several matching functions which were introduced in the lecture, namely cross-correlation(normalized), cross-correlation, convolution, and SSD. Then all image samples shown above are fed into those classifiers seperately and the corresponding scores are printed out at the end of the cell.\n",
    "\n",
    "The results of all template matching skills are printed out at the end of the cell. Apparently, only NCC shows the ability to classify the same face pair and different faces pair. Therefore, in this assignment, the classifier will be built based on Normalized Cross-Correlation. And the corresponding **threshold is set $0.6$**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------- same faces ------------------------------------\n",
      "NCC:1.0 \t \t \t Conv:84.91780926074851 \t SSD:0.0\n",
      "NCC:0.7177882918040279 \t \t Conv:34.39739781668252 \t SSD:266.91643021914643\n",
      "NCC:0.6618261099181423 \t \t Conv:27.32804301155204 \t SSD:294.1769127258746\n",
      "------------------------------- different faces ----------------------------------\n",
      "NCC:0.5338608734949605 \t \t Conv:60.85439800187653 \t SSD:163.69754036908876\n",
      "NCC:0.2861959200424425 \t \t Conv:17.488654840536064 \t SSD:252.9331487889273\n",
      "NCC:0.38768792843956684 \t Conv:20.040709458482795 \t SSD:236.74956843521716\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def NormalizedCrossCorrelation(image1, image2):\n",
    "    \"\"\"\n",
    "    Funtion: calculating normalized cross correlation (NCC) between two images\n",
    "    \"\"\"\n",
    "    numerator = np.sum((image1 - np.mean(image1)) * (image2 - np.mean(image2)))\n",
    "    denominator = np.sqrt(np.sum(np.square(image1 - np.mean(image1))) * \\\n",
    "                          np.sum(np.square(image2 - np.mean(image2))))\n",
    "    return numerator / denominator\n",
    "\n",
    "def Convolution(image1, image2):\n",
    "    \"\"\"\n",
    "    Funtion: calculating convolution between two images\n",
    "    \"\"\"\n",
    "    return np.sum(np.flip((image1 - image1.mean())) * image2)\n",
    "\n",
    "def SumSquareDifferences(image1, image2):\n",
    "    \"\"\"\n",
    "    Funtion: calculating pixel differences between two images\n",
    "    \"\"\"\n",
    "    return np.sum(np.square(image1 - image2))\n",
    "\n",
    "def CompareAllTricks(image1, image2):\n",
    "    \"\"\"\n",
    "    Function: compare the scores w.r.t 3 methods and choose the best one\n",
    "    \"\"\"\n",
    "    a = NormalizedCrossCorrelation(image1, image2)\n",
    "    b = Convolution(image1, image2)\n",
    "    c = SumSquareDifferences(image1, image2)\n",
    "    return [a, b, c]\n",
    "\n",
    "# try differences betwwen correlation, convolution and squared differences\n",
    "# try with same faces but different illumination\n",
    "compare_example_1 = CompareAllTricks(image_example_1, image_example_2)\n",
    "compare_example_2 = CompareAllTricks(image_example_1, image_example_3)\n",
    "compare_example_3 = CompareAllTricks(image_example_1, image_example_4)\n",
    "# try with different faces with different illumination\n",
    "compare_example_4 = CompareAllTricks(image_example_1, image_example_5)\n",
    "compare_example_5 = CompareAllTricks(image_example_1, image_example_6)\n",
    "compare_example_6 = CompareAllTricks(image_example_1, image_example_7)\n",
    "\n",
    "print(\"---------------------------------- same faces ------------------------------------\")\n",
    "print(\"NCC:{} \\t \\t \\t Conv:{} \\t SSD:{}\".format(compare_example_1[0], compare_example_1[1], compare_example_1[2]))\n",
    "print(\"NCC:{} \\t \\t Conv:{} \\t SSD:{}\".format(compare_example_2[0], compare_example_2[1], compare_example_2[2]))\n",
    "print(\"NCC:{} \\t \\t Conv:{} \\t SSD:{}\".format(compare_example_3[0], compare_example_3[1], compare_example_3[2]))\n",
    "print(\"------------------------------- different faces ----------------------------------\")\n",
    "print(\"NCC:{} \\t \\t Conv:{} \\t SSD:{}\".format(compare_example_4[0], compare_example_4[1], compare_example_4[2]))\n",
    "print(\"NCC:{} \\t \\t Conv:{} \\t SSD:{}\".format(compare_example_5[0], compare_example_5[1], compare_example_5[2]))\n",
    "print(\"NCC:{} \\t Conv:{} \\t SSD:{}\".format(compare_example_6[0], compare_example_6[1], compare_example_6[2]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='classifier_and_validate_the_results'></a>\n",
    "\n",
    "## 2.2 Classifier and Validate the results\n",
    "\n",
    "First, since the validation set is relatively small when compared to other data sets, all the images of the set are read and then saved into RAM with the labels.\n",
    "\n",
    "A classifier is built based on NCC with threshold $0.6$.\n",
    "\n",
    "All image pairs in the validation set are then sent into the classifier and the predictions are compared with the ground truth labels to give the accuracy result. Also, a timer is set during the whole prediction process in order to find out how much time it costs. All results are printed out at the end of the cell.\n",
    "\n",
    "Clearly, the accuracy of the current classifier is about $75$%. It is moderately reasonable because only one image processing skill is applied onto the classifier.\n",
    "\n",
    "Random results of same face pair prediction and different faces pair prediction with corresponding images are plotted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------- validation results ----------------------------------\n",
      "The accuracy of NCC classifier on the validation is: \t\t 0.73554504\n",
      "The whole prediction process on the validation set costs: \t 0.17907047271728516  sec\n",
      "\n",
      "\n",
      "------------------------- random prediction samples -------------------------------\n",
      "label of this pair is: \t same face\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label of this pair is: \t different faces\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def NCCClassifier(img1, img2, NCC_threshold = 0.6):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Build a classifier to tell whether two images are showing the same\n",
    "    face or not.\n",
    "    \"\"\"\n",
    "    score = NormalizedCrossCorrelation(img1, img2)\n",
    "    if score >= NCC_threshold:\n",
    "#         pred = 1\n",
    "        pred = [1, 0]\n",
    "    else:\n",
    "#         pred = 0\n",
    "        pred = [0, 1]\n",
    "    return pred\n",
    "\n",
    "def AccuracyCalculation(pred, label):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Find out the accuracy reasults on the validation set\n",
    "    \"\"\"\n",
    "    results_masks = np.equal(pred, label).astype(np.float32)\n",
    "    accuracy = np.mean(results_masks)\n",
    "    return accuracy\n",
    "\n",
    "def NCCClassifierOnSet(imgs1, imgs2, NCC_threshold):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Get the accuracy results on the whole set.\n",
    "    \"\"\"\n",
    "    all_prediction = []\n",
    "    for i in range(len(imgs1)):\n",
    "        current_img_1 = imgs1[i]\n",
    "        current_img_2 = imgs2[i]\n",
    "        current_pred = NCCClassifier(current_img_1, current_img_2, NCC_threshold)\n",
    "        all_prediction.append(current_pred)\n",
    "    all_prediction = np.array(all_prediction)\n",
    "    return all_prediction\n",
    "\n",
    "def ReadValidationSetAsImages(validation_set, train_on_MLP = False):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Read all images from validation set and store it in RAM, since \n",
    "    the size of validation set is not that big.\n",
    "    \"\"\"\n",
    "    first_img_all = []\n",
    "    second_img_all = []\n",
    "    img_concat_all = []\n",
    "    labels_all = []\n",
    "    for i in range(len(validation_set)):\n",
    "        current_validation = validation_set[i]\n",
    "        # get first image\n",
    "        image1 = ReadImage(current_validation[0])\n",
    "        # get second image\n",
    "        image2 = ReadImage(current_validation[1])\n",
    "        label = np.ones(2)\n",
    "        label[current_validation[2]] = 0.\n",
    "#         label = current_validation[2]\n",
    "        if train_on_MLP:\n",
    "            # if is for MLP, concatenate images and reshape\n",
    "            img_concat_all.append(np.concatenate([image1, image2], axis = 0).reshape(-1))\n",
    "        else:\n",
    "            # if for NCC classifier, just return images\n",
    "            first_img_all.append(image1)\n",
    "            second_img_all.append(image2)\n",
    "        labels_all.append(label)\n",
    "    labels_all = np.array(labels_all)\n",
    "    # different returns according to different requirements\n",
    "    if train_on_MLP:\n",
    "        img_concat_all = np.array(img_concat_all)\n",
    "        return img_concat_all, labels_all\n",
    "    else:\n",
    "        first_img_all = np.array(first_img_all)\n",
    "        second_img_all = np.array(second_img_all)\n",
    "        return first_img_all, second_img_all, labels_all\n",
    "    \n",
    "def ShowRandomPair(imgs1, imgs2, preds, sample_same_face = True):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Show random pairs of the NCC classifier prediction to visualize the result.\n",
    "    \"\"\"\n",
    "    if sample_same_face:\n",
    "#         target = 1\n",
    "        target = [1, 0]\n",
    "        label_show = \"same face\"\n",
    "    else:\n",
    "#         target = 0\n",
    "        target = [0, 1]\n",
    "        label_show = \"different faces\"\n",
    "#     imgs1_select = imgs1[preds = target]\n",
    "#     imgs2_select = imgs2[preds = target]\n",
    "    imgs1_select = imgs1[preds[:, 0] == target[0]]\n",
    "    imgs2_select = imgs2[preds[:, 0] == target[0]]\n",
    "    random_ind = np.random.randint(len(imgs1_select))\n",
    "    display_imgs = np.concatenate([imgs1_select[random_ind], imgs2_select[random_ind]], axis = 1)\n",
    "    print(\"label of this pair is: \\t\", label_show)\n",
    "    plt.imshow(display_imgs)\n",
    "    plt.show()\n",
    "    \n",
    "valid_imgs_1, valid_imgs_2, valid_labels = ReadValidationSetAsImages(validation_set, False)\n",
    "\n",
    "# setting threshold for same faces\n",
    "NCC_threshold = 0.6\n",
    "# get the predictions of NCC classifier\n",
    "start_time = time.time()\n",
    "classifier_predictions = NCCClassifierOnSet(valid_imgs_1, valid_imgs_2, NCC_threshold)\n",
    "time_duration = time.time() - start_time\n",
    "# get the accuracy on the validation set\n",
    "classifier_validation_accuracy = AccuracyCalculation(classifier_predictions, valid_labels)\n",
    "\n",
    "print(\"----------------------------- validation results ----------------------------------\")\n",
    "print(\"The accuracy of NCC classifier on the validation is: \\t\\t\", classifier_validation_accuracy)\n",
    "print(\"The whole prediction process on the validation set costs: \\t\", time_duration, \" sec\")\n",
    "\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"------------------------- random prediction samples -------------------------------\")\n",
    "ShowRandomPair(valid_imgs_1, valid_imgs_2, classifier_predictions, True)\n",
    "ShowRandomPair(valid_imgs_1, valid_imgs_2, classifier_predictions, False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='perceptron'></a>\n",
    "\n",
    "# 3. Perceptron\n",
    "\n",
    "First, the reason why there is a input generator is because the size of the training data set is too big. It has more than $10,000$ images which makes it impossible to read all images and store them into RAM once and for all. Therefore, a data generator is built for better memory orgnization.\n",
    "\n",
    "Second, the MLP model structure in this assignmen can be described as,\n",
    "\n",
    "    [batch, 128 * 64 * 3] -> [batch, 1024] -> [batch, 256] -> [batch, 64] -> [batch, 1]\n",
    "\n",
    "Other parameters are set as:\n",
    "\n",
    "- activation function of hidden layers: \"relu\";\n",
    "- gating function: \"sigmoid\";\n",
    "- loss function: \"binary cross entropy\";\n",
    "- optimizer: \"Adam\";\n",
    "- batch size: $256$;\n",
    "- epoches: $2$ (because the training process is really slow);\n",
    "\n",
    "The loss value and validation accuracy are checked at each batch. And finally, all check points are saved into numpy array for further usage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/tensorflow/python/framework/dtypes.py:523: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/usr/local/lib/python3.5/dist-packages/tensorflow/python/framework/dtypes.py:524: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/usr/local/lib/python3.5/dist-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/usr/local/lib/python3.5/dist-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/usr/local/lib/python3.5/dist-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/usr/local/lib/python3.5/dist-packages/tensorflow/python/framework/dtypes.py:532: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "Using TensorFlow backend.\n",
      "  0%|          | 0/2 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current_batch: 407/408, train_loss: 0.06719938665628433, train_acc: 0.9765625, valid_loss: 0.0782846095084579, valid_acc: 0.96777251100088188296\r"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      " 50%|█████     | 1/2 [46:43<46:43, 2803.21s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current_batch: 329/408, train_loss: 0.015213200822472572, train_acc: 0.9921875, valid_loss: 0.005867816098210936, valid_acc: 0.999052132701421818\r"
     ]
    }
   ],
   "source": [
    "##### set specific gpu #####\n",
    "import os\n",
    "os.environ[\"CUDA_DEVICE_ORDER\"]=\"PCI_BUS_ID\"\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\"\n",
    "##### start other dependencies #####\n",
    "import tensorflow as tf\n",
    "import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.optimizers import Adam\n",
    "from keras import backend as K\n",
    "\n",
    "K.clear_session()\n",
    "\n",
    "def InputAndOutputGenerator(data_pathes, batch_size):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Since when transfer into images, dataset is too big to read it all at once, a generator\n",
    "    is created to generate the data according to the batch_size\n",
    "    \"\"\"\n",
    "    # get number of batches\n",
    "    num_batch = len(data_pathes) // batch_size\n",
    "    for batch_id in range(num_batch):\n",
    "        # get batch data\n",
    "        data_path_batch = data_pathes[batch_id*batch_size: (batch_id+1)*batch_size]\n",
    "        batch_inputs = []\n",
    "        batch_labels = []\n",
    "        # get every data in each batch\n",
    "        for i in range(len(data_path_batch)):\n",
    "            current_data = data_path_batch[i]\n",
    "            # read images (resized)\n",
    "            img1 = ReadImage(current_data[0])\n",
    "            img2 = ReadImage(current_data[1])\n",
    "            # concatenate images\n",
    "            img_concat = np.concatenate([img1, img2], axis = 0)\n",
    "            # reshape input data\n",
    "            each_input = img_concat.reshape((-1,))\n",
    "            # get label as one hot format\n",
    "            label = np.ones(2)\n",
    "            label[current_data[2]] = 0.\n",
    "#             label = float(current_data[2])\n",
    "            # orgnizing input and output\n",
    "            batch_inputs.append(each_input)\n",
    "            batch_labels.append(label)\n",
    "        batch_inputs = np.array(batch_inputs)\n",
    "        batch_labels = np.array(batch_labels)\n",
    "        yield (batch_inputs, batch_labels)\n",
    "\n",
    "def MLPModel():\n",
    "    \"\"\"\n",
    "    Building the MLP model\n",
    "    \"\"\"\n",
    "    model = Sequential()\n",
    "    # structure: (batch, 128*64*3) -> (batch, 256) -> (batch, 64) -> (batch, 1)\n",
    "    model.add(Dense(units = 256, activation = \"relu\", input_dim = 128 * 64 * 3))\n",
    "    model.add(Dense(units = 128, activation = \"relu\"))\n",
    "    model.add(Dense(units = 64, activation = \"relu\"))\n",
    "    model.add(Dense(units = 32, activation = \"relu\"))\n",
    "    model.add(Dense(units = 2, activation = \"softmax\"))\n",
    "    # using cross entropy as loss and adam as optimizer\n",
    "    model.compile(loss='categorical_crossentropy',\n",
    "                  optimizer='adam',\n",
    "                  metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "# get validation set for MLP\n",
    "valid_inputs, valid_labels = ReadValidationSetAsImages(validation_set, True)\n",
    "\n",
    "# define model.fit_generator parameters.\n",
    "batch_size = 256\n",
    "num_batch_train = len(train_set) // batch_size\n",
    "\n",
    "# gpu memory\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "keras.backend.tensorflow_backend.set_session(tf.Session(config=config))\n",
    "\n",
    "# get model\n",
    "model = MLPModel()\n",
    "\n",
    "# training and validating on each batch\n",
    "epoches = 2\n",
    "train_loss = []\n",
    "train_acc = []\n",
    "valid_loss = []\n",
    "valid_acc = []\n",
    "total_validation_time = []\n",
    "for each_epoch in tqdm(range(epoches)):\n",
    "    count = 0\n",
    "    for data_train in InputAndOutputGenerator(train_set, batch_size):\n",
    "        count += 1\n",
    "        train_los_metr =  model.train_on_batch(data_train[0], data_train[1])\n",
    "        start_time = time.time()\n",
    "        val_los_metr = model.evaluate(valid_inputs, valid_labels, verbose=0)\n",
    "        time_duration = time.time() - start_time\n",
    "        total_validation_time.append(time_duration)\n",
    "        train_loss.append(train_los_metr[0])\n",
    "        train_acc.append(train_los_metr[1])\n",
    "        valid_loss.append(val_los_metr[0])\n",
    "        valid_acc.append(val_los_metr[1])\n",
    "        print(\"current_batch: {}/{}, train_loss: {}, train_acc: {}, valid_loss: {}, valid_acc: {}\"\\\n",
    "              .format(count, num_batch_train, train_los_metr[0], train_los_metr[1], val_los_metr[0], val_los_metr[1]), end = \"\\r\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to visualize the learning effort, all saved checked points are called and the corresponding loss value and validation accuracy are plotted out at the end of the cell.\n",
    "\n",
    "Apparently, the loss value goes down extremely fast at the very bignning before it slows down its convergence speed. At the end of the training, the validation accuracy reaches over $95$%, which is relatively higher than the NCC classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "print(\"The accuracy of MLP on the validation is: \\t\", valid_acc[-1])\n",
    "\n",
    "display_steps = int(1 * len(train_loss))\n",
    "\n",
    "fig = plt.figure(figsize = (12, 5))\n",
    "ax1 = fig.add_subplot(121)\n",
    "ax2 = fig.add_subplot(122)\n",
    "ax1.plot(train_loss[:display_steps], 'r')\n",
    "ax1.set_title(\"training loss\")\n",
    "ax1.set_xlabel(\"training steps\")\n",
    "ax1.set_ylabel(\"loss value\")\n",
    "ax2.plot(valid_acc[:display_steps], 'b')\n",
    "ax2.set_title(\"validation accuracy\")\n",
    "ax2.set_xlabel(\"training steps\")\n",
    "ax2.set_ylabel(\"accuracy\")\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='classification_comparison'></a>\n",
    "\n",
    "# 4. Classification Comparison\n",
    "\n",
    "The NCC classifier and the MLP are tested seprately on the test set, which consists of the data from subset 31 to 40. All results are printed out at the end of the cell.\n",
    "\n",
    "A brief conclusion could be drawn as below,\n",
    "1. NCC classifier shows a very prosiming results on the image pairs showing the same face. Although, MLP performances well on this set, but the result is lower than the NCC classifier. The reason is because of the unbalanced dataset portion. Since test set itself has totally $73536$ image pairs with only $8448$ paris showing the same face, there lacks enough information about same faces for the model to learn.\n",
    "2. This immediately verifies the reason above. Since there are enough image pairs for MLP to learn different faces, the MLP extremely outperforms the NCC classifier for the different faces.\n",
    "3. Overall, the performance for the MLP is better than the NCC classifier.\n",
    "4. For the prediction speed, it is highly related to the model complexity.\n",
    "\n",
    "Other comparisons are concluded as below,\n",
    "1. The training effort of NCC classifier involves much human work, but within several samples, the classifier could be set down with relatively good prediction results. On the contrary, although there is no human labour involved in the MLP, it requires huge dataset for the model to give the right predicitons.\n",
    "2. For robustness, I think, with enough data, MLP could be more reliable and stable than the NCC classifier.\n",
    "3. For generalization, since in the real world, enough data sets are not always the case, people normally tend to combine different traiditional processing skills to derive the dataset. Therefore, no matter it is NCC classifier or MLP, they should be used in the right places when consider different situations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def NCCTestOnBatch(test_set, batch_size):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Evaluate the NCC classifier on the test set.\n",
    "    \"\"\"\n",
    "    batch_count = 0\n",
    "    total_batch = len(test_set) // batch_size\n",
    "    total_time = []\n",
    "    all_acc = []\n",
    "    for batch_id in range(total_batch):\n",
    "        current_batch = test_set[batch_id*batch_size: (batch_id+1)*batch_size]\n",
    "        current_imgs_1, current_imgs_2, current_labels = ReadValidationSetAsImages(current_batch, False)\n",
    "        start_time = time.time()\n",
    "        current_predictions = NCCClassifierOnSet(current_imgs_1, current_imgs_2, NCC_threshold)\n",
    "        current_validation_accuracy = AccuracyCalculation(current_predictions, current_labels)\n",
    "        time_duration = time.time() - start_time\n",
    "        print(\"current batch: {}/{}, test batch result: {}\".format(batch_count, total_batch, \\\n",
    "                                                                   current_validation_accuracy), end=\"\\r\")\n",
    "        all_acc.append(current_validation_accuracy)\n",
    "        total_time.append(time_duration)\n",
    "        batch_count += 1\n",
    "    print(\"---------------------- test results ---------------------------\")\n",
    "    average_time = np.mean(total_time)\n",
    "    average_acc = np.mean(all_acc)\n",
    "    return average_acc, average_time\n",
    "\n",
    "def MLPTestOnBatch(test_set, batch_size):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Evaluate the MLP model on the test set.\n",
    "    \"\"\"\n",
    "    batch_count = 0\n",
    "    total_batch = len(test_set) // batch_size\n",
    "    total_time = []\n",
    "    all_results = []\n",
    "    # test on batch since the dataset size is too big\n",
    "    for data_test in InputAndOutputGenerator(test_set, batch_size):\n",
    "        start_time = time.time()\n",
    "        test_result = model.evaluate(data_test[0], data_test[1], verbose = 0)\n",
    "#         pred_result =  model.predict(data_test[0], verbose=0)\n",
    "#         pred_result = np.where(pred_result > 0.5, 1., 0.)\n",
    "#         test_result = AccuracyCalculation(pred_result, data_test[1])\n",
    "        print(\"current batch: {}/{}, test batch result: {}\".format(batch_count, total_batch, \\\n",
    "                                                                   test_result), end=\"\\r\")\n",
    "        time_duration = (time.time() - start_time)\n",
    "        total_time.append(time_duration)\n",
    "        all_results.append(test_result[1])\n",
    "        batch_count += 1\n",
    "    print(\"----------------------------- fresh results -------------------------------\")\n",
    "    average_time = np.mean(total_time)\n",
    "    final_results = np.mean(all_results)\n",
    "    return final_results, average_time\n",
    "\n",
    "print(\"\\n\")\n",
    "NCC_acc_same, NCC_time_same = NCCTestOnBatch(test_same_set, batch_size)\n",
    "print(\"Accuracy of NCC classifier on the same face data:\\t\", NCC_acc_same, \\\n",
    "      \"\\nwith average prediction time:\\t\", NCC_time_same)\n",
    "NCC_acc_diff, NCC_time_diff = NCCTestOnBatch(test_diff_set, batch_size)\n",
    "print(\"Accuracy of NCC classifier on the different face data:\\t\", NCC_acc_diff, \\\n",
    "      \"\\nwith average prediction time:\\t\", NCC_time_diff)\n",
    "NCC_acc_all, NCC_time_all = NCCTestOnBatch(test_set, batch_size)\n",
    "print(\"Accuracy of NCC classifier on the all data:\\t\", NCC_acc_all, \\\n",
    "      \"\\nwith average prediction time:\\t\", NCC_time_all)\n",
    "\n",
    "print(\"\\n\")\n",
    "MLP_acc_same, MLP_time_same = MLPTestOnBatch(test_same_set, batch_size)\n",
    "print(\"Accuracy of NCC classifier on the same face data:\\t\", MLP_acc_same, \\\n",
    "      \"\\nwith average prediction time:\\t\\t\\t\\t\", MLP_time_same)\n",
    "MLP_acc_diff, MLP_time_diff = MLPTestOnBatch(test_diff_set, batch_size)\n",
    "print(\"Accuracy of NCC classifier on the different face data:\\t\", MLP_acc_diff, \\\n",
    "      \"\\nwith average prediction time:\\t\\t\\t\\t\", MLP_time_diff)\n",
    "MLP_acc_all, MLP_time_all = MLPTestOnBatch(test_set, batch_size)\n",
    "print(\"Accuracy of NCC classifier on the all data:\\t\", MLP_acc_all, \\\n",
    "      \"\\nwith average prediction time:\\t\\t\\t\\t\", MLP_time_all)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='Feature_engineering'></a>\n",
    "\n",
    "# 5. Feature Engineering\n",
    "\n",
    "<a id='feature_extraction'></a>\n",
    "\n",
    "## 5.1 Feature Extraction\n",
    "\n",
    "First of all, since all box filters technically belong to the cross-correlation familes, featire extraction kernels, such as Sober, Prewitt, and Robert are also special cross-correlations.\n",
    "\n",
    "Several processing skills have been tried in this assignment, and finally the pre-process is settled as,\n",
    "1. Grayscale the image.\n",
    "2. Apply histogram equalization on the image to emphasize the contrast.\n",
    "3. Use Sobel kernel to extract the gradient of the image.\n",
    "\n",
    "With all the steps described above, the outline of the face is finally extracted out. Same image samples which were used in the first section are used again for the comparison. Images are plotted at the end of the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage.color import rgb2gray\n",
    "from skimage.exposure import equalize_hist\n",
    "from skimage.filters import roberts, sobel\n",
    "\n",
    "def GrayGradient(img):\n",
    "    \"\"\"\n",
    "    Function: \n",
    "        Find the gradient of the image after grayscaled\n",
    "    \"\"\"\n",
    "    gray_img = rgb2gray(img)\n",
    "    return sobel(gray_img)\n",
    "\n",
    "def GrayHistSobel(img):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Apply histogram equalization on the grayscaled image first,\n",
    "    then find the gradient.\n",
    "    \"\"\"\n",
    "    gray_img = rgb2gray(img)\n",
    "    gray_hist = equalize_hist(gray_img)\n",
    "    return sobel(gray_hist)\n",
    "\n",
    "# try image processing skills on all the example images\n",
    "image_processsample_1 = GrayHistSobel(image_example_1)\n",
    "image_processsample_2 = GrayHistSobel(image_example_2)\n",
    "image_processsample_3 = GrayHistSobel(image_example_3)\n",
    "image_processsample_4 = GrayHistSobel(image_example_4)\n",
    "image_processsample_5 = GrayHistSobel(image_example_5)\n",
    "image_processsample_6 = GrayHistSobel(image_example_6)\n",
    "image_processsample_7 = GrayHistSobel(image_example_7)\n",
    "\n",
    "# try with same faces but different illumination\n",
    "sample1 = np.concatenate([image_processsample_1, image_processsample_2], axis = 1)\n",
    "sample2 = np.concatenate([image_processsample_1, image_processsample_3], axis = 1)\n",
    "sample3 = np.concatenate([image_processsample_1, image_processsample_4], axis = 1)\n",
    "# try with different faces with different illumination\n",
    "sample4 = np.concatenate([image_processsample_1, image_processsample_5], axis = 1)\n",
    "sample5 = np.concatenate([image_processsample_1, image_processsample_6], axis = 1)\n",
    "sample6 = np.concatenate([image_processsample_1, image_processsample_7], axis = 1)\n",
    "\n",
    "\n",
    "# show results of the same faces\n",
    "fig = plt.figure(figsize = (12, 4))\n",
    "ax1 = fig.add_subplot(131)\n",
    "ax2 = fig.add_subplot(132)\n",
    "ax3 = fig.add_subplot(133)\n",
    "ax1.imshow(sample1)\n",
    "ax2.imshow(sample2)\n",
    "ax3.imshow(sample3)\n",
    "plt.show()\n",
    "\n",
    "# show results of different faces\n",
    "fig = plt.figure(figsize = (12, 4))\n",
    "ax1 = fig.add_subplot(131)\n",
    "ax2 = fig.add_subplot(132)\n",
    "ax3 = fig.add_subplot(133)\n",
    "ax1.imshow(sample4)\n",
    "ax2.imshow(sample5)\n",
    "ax3.imshow(sample6)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='train_on_new_data'></a>\n",
    "\n",
    "## 5.2 Train on New data\n",
    "\n",
    "A similar MLP model is built for training the image pairs. The only difference it has from the previous model is that the input size shrink from $128*64*3$ to $128*64$, since the images are transferred to the gradient features in the first place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "K.clear_session()\n",
    "\n",
    "def ValidationSetForNewMLP(validation_set):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Read all images from validation set and store it in RAM, since \n",
    "    the size of validation set is not that big.\n",
    "    \"\"\"\n",
    "    img_concat_all = []\n",
    "    labels_all = []\n",
    "    for i in range(len(validation_set)):\n",
    "        current_validation = validation_set[i]\n",
    "        # get first image\n",
    "        image1 = GrayHistSobel(ReadImage(current_validation[0]))\n",
    "        # get second image\n",
    "        image2 = GrayHistSobel(ReadImage(current_validation[1]))\n",
    "        label = current_validation[2]\n",
    "        # concatenate images and reshape\n",
    "        img_concat_all.append(np.concatenate([image1, image2], axis = 0).reshape(-1))\n",
    "        labels_all.append(label)\n",
    "    labels_all = np.array(labels_all)\n",
    "    img_concat_all = np.array(img_concat_all)\n",
    "    return img_concat_all, labels_all\n",
    "\n",
    "def NewGenerator(data_pathes, batch_size):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Since when transfer into images, dataset is too big to read it all at once, a generator\n",
    "    is created to generate the data according to the batch_size\n",
    "    \"\"\"\n",
    "    # get number of batches\n",
    "    num_batch = len(data_pathes) // batch_size\n",
    "    for batch_id in range(num_batch):\n",
    "        # get batch data\n",
    "        data_path_batch = data_pathes[batch_id*batch_size: (batch_id+1)*batch_size]\n",
    "        batch_inputs = []\n",
    "        batch_labels = []\n",
    "        # get every data in each batch\n",
    "        for i in range(len(data_path_batch)):\n",
    "            current_data = data_path_batch[i]\n",
    "            # read images (resized)\n",
    "            img1 = GrayHistSobel(ReadImage(current_data[0]))\n",
    "            img2 = GrayHistSobel(ReadImage(current_data[1]))\n",
    "            # concatenate images\n",
    "            img_concat = np.concatenate([img1, img2], axis = 0)\n",
    "            # reshape input data\n",
    "            each_input = img_concat.reshape((-1,))\n",
    "            # get label as one hot format\n",
    "            label = np.ones(2)\n",
    "            label[current_data[2]] = 0.\n",
    "#             label = float(current_data[2])\n",
    "            # orgnizing input and output\n",
    "            batch_inputs.append(each_input)\n",
    "            batch_labels.append(label)\n",
    "        batch_inputs = np.array(batch_inputs)\n",
    "        batch_labels = np.array(batch_labels)\n",
    "        yield (batch_inputs, batch_labels)\n",
    "\n",
    "def NewMLPModel():\n",
    "    \"\"\"\n",
    "    Building the MLP model\n",
    "    \"\"\"\n",
    "    model = Sequential()\n",
    "    # structure: (batch, 128*64*3) -> (batch, 256) -> (batch, 64) -> (batch, 1)\n",
    "    model.add(Dense(units = 256, activation = \"relu\", input_dim = 128 * 64))\n",
    "    model.add(Dense(units = 128, activation = \"relu\"))\n",
    "    model.add(Dense(units = 64, activation = \"relu\"))\n",
    "    model.add(Dense(units = 32, activation = \"relu\"))\n",
    "    model.add(Dense(units = 2, activation = \"softmax\"))\n",
    "    # using cross entropy as loss and adam as optimizer\n",
    "    model.compile(loss='categorical_crossentropy',\n",
    "                  optimizer='adam',\n",
    "                  metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "# get validation set for new MLP\n",
    "new_validation_inputs, new_validation_labels = ValidationSetForNewMLP(validation_set)\n",
    "\n",
    "# gpu memory\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "keras.backend.tensorflow_backend.set_session(tf.Session(config=config))\n",
    "\n",
    "# get model\n",
    "model_new = NewMLPModel()\n",
    "\n",
    "# training and validating on each batch\n",
    "epoches = 2\n",
    "train_loss_new = []\n",
    "train_acc_new = []\n",
    "valid_loss_new = []\n",
    "valid_acc_new = []\n",
    "total_validation_time_new = []\n",
    "for each_epoch in tqdm(range(epoches)):\n",
    "    count = 0\n",
    "    for data_train_new in NewGenerator(train_set, batch_size):\n",
    "        count += 1\n",
    "        train_los_metr_new =  model_new.train_on_batch(data_train_new[0], data_train_new[1])\n",
    "        start_time = time.time()\n",
    "        val_los_metr_new = model_new.evaluate(new_validation_inputs, new_validation_labels, \\\n",
    "                                              verbose=0)\n",
    "        time_duration = time.time() - start_time\n",
    "        total_validation_time_new.append(time_duration)\n",
    "        train_loss_new.append(train_los_metr_new[0])\n",
    "        train_acc_new.append(train_los_metr_new[1])\n",
    "        valid_loss_new.append(val_los_metr_new[0])\n",
    "        valid_acc_new.append(val_los_metr_new[1])\n",
    "        print(\"current_batch: {}/{}, train_loss: {}, train_acc: {}, valid_loss: {}, valid_acc: {}\"\\\n",
    "              .format(count, num_batch_train, train_los_metr_new[0], train_los_metr_new[1], \\\n",
    "                      val_los_metr_new[0], val_los_metr_new[1]), end = \"\\r\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='results_and_conclusion'></a>\n",
    "\n",
    "## 5.3 Results and Conclusion\n",
    "\n",
    "First of all, as usual, the plots of the training process and the validation process are plotted out below. One can see that the no matter the convergence speed or the performance, they are better than the previous model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "print(\"The accuracy of MLP on the validation is: \\t\\t\", valid_acc_new[-1])\n",
    "print(\"The whole prediction process of MLP on the validation set costs: \\t\", np.mean(total_validation_time_new), \" sec\")\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize = (12, 5))\n",
    "ax1 = fig.add_subplot(121)\n",
    "ax2 = fig.add_subplot(122)\n",
    "ax1.plot(train_loss_new, 'r')\n",
    "ax1.set_title(\"training loss\")\n",
    "ax1.set_xlabel(\"training steps\")\n",
    "ax1.set_ylabel(\"loss value\")\n",
    "ax2.plot(valid_acc_new, 'b')\n",
    "ax2.set_title(\"validation acccuracy\")\n",
    "ax2.set_xlabel(\"training steps\")\n",
    "ax2.set_ylabel(\"accuracy\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, the test on the whole test set is conducted. Results are printed out at the end.\n",
    "\n",
    "Brief conclusion would be,\n",
    "1. The reason why it way outperforms either NCC classifer or original MLP is that, it is complex than the normal image processing skill and it takes only the key feature of the image instead of the image itself. This could make the model quickly learn what it needs to tell two images are showing the same face or not. \n",
    "2. Since the new model take the inputs sized $1/3$ of the original image data, it speeds up both the training process and the prediction process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def NewMLPTestOnBatch(test_set, batch_size):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Evaluate the MLP model on the test set.\n",
    "    \"\"\"\n",
    "    batch_count = 0\n",
    "    total_batch = len(test_set) // batch_size\n",
    "    total_time = []\n",
    "    all_results = []\n",
    "    # test on batch since the dataset size is too big\n",
    "    for data_test in NewGenerator(test_set, batch_size):\n",
    "        start_time = time.time()\n",
    "        test_result = model_new.evaluate(data_test[0], data_test[1], verbose = 0)\n",
    "#         pred_result =  model_new.predict(data_test[0], verbose=0)\n",
    "#         pred_result = np.where(pred_result > 0.5, 1., 0.)\n",
    "#         test_result = AccuracyCalculation(pred_result, data_test[1])\n",
    "#         test_result =  model_new.evaluate(data_test[0], data_test[1], verbose=1)\n",
    "        print(\"current batch: {}/{}, test batch result: {}\".format(batch_count, total_batch, \\\n",
    "                                                                   test_result), end=\"\\r\")\n",
    "        time_duration = (time.time() - start_time)\n",
    "        total_time.append(time_duration)\n",
    "        all_results.append(test_result)\n",
    "        batch_count += 1\n",
    "    print(\"----------------------------- fresh results -------------------------------\")\n",
    "    average_time = np.mean(total_time)\n",
    "    final_results = np.mean(all_results)\n",
    "    return final_results, average_time\n",
    "\n",
    "MLP_acc_same_new, MLP_time_same_new = NewMLPTestOnBatch(test_same_set, batch_size)\n",
    "print(\"Accuracy of NCC classifier on the same face data:\\t\", MLP_acc_same_new, \\\n",
    "      \" average prediction time:\\t\", MLP_time_same_new)\n",
    "MLP_acc_diff_new, MLP_time_diff_new = NewMLPTestOnBatch(test_diff_set, batch_size)\n",
    "print(\"Accuracy of NCC classifier on the different face data:\\t\", MLP_acc_diff_new, \\\n",
    "      \" average prediction time:\\t\", MLP_time_diff_new)\n",
    "MLP_acc_all_new, MLP_time_all_new = NewMLPTestOnBatch(test_set, batch_size)\n",
    "print(\"Accuracy of NCC classifier on the all data:\\t\", MLP_acc_all_new, \\\n",
    "      \" average prediction time:\\t\", MLP_time_all_new)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}