assignment2/Untitled.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "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",
    "from skimage.io import imread\n",
    "from skimage.transform import resize\n",
    "import matplotlib.pyplot as plt\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 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",
    "    return image\n",
    "\n",
    "def GetImageWithSubName(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",
    "    image = ReadImage(image_path)\n",
    "    sub_name = sub\n",
    "    return image, sub_name\n",
    "\n",
    "def GetAllData(sub_names, session_names, frame_names):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Read all images in the dataset with their subset names.\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_imgs= []\n",
    "    all_subs = []\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, image_sub = GetImageWithSubName(sub, sess, frame)\n",
    "                all_imgs.append(image)\n",
    "                all_subs.append(image_sub)\n",
    "    all_imgs = np.array(all_imgs)\n",
    "    all_subs = np.array(all_subs)\n",
    "    return all_imgs, all_subs\n",
    "\n",
    "def PairWithIndex(all_subs):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Pair each two images with the image indexes, then define labels.\n",
    "    \"\"\"\n",
    "    imgs_ind = np.arange(len(all_subs))\n",
    "    all_pairs = []\n",
    "    # loop over each image with the rest images\n",
    "    while len(imgs_ind) > 0:\n",
    "        current_img_ind = imgs_ind[0]\n",
    "        imgs_ind = np.delete(imgs_ind, 0)\n",
    "        for another_img_ind in imgs_ind:\n",
    "            if all_subs[current_img_ind] == all_subs[another_img_ind]:\n",
    "                label = 1\n",
    "            else:\n",
    "                label = 0\n",
    "            all_pairs.append([current_img_ind, another_img_ind, label])\n",
    "    all_pairs = np.array(all_pairs)\n",
    "    return all_pairs\n",
    "\n",
    "def TrainValidSep(all_pairs, validation_rate = 0.01):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Separate the dataset for training into train set and validation set.\n",
    "    \"\"\"\n",
    "    same_pairs = all_pairs[all_pairs[:, 2] == 1]\n",
    "    diff_pairs = all_pairs[all_pairs[:, 2] == 0]\n",
    "    # shuffle two sets first\n",
    "    np.random.shuffle(same_pairs)\n",
    "    np.random.shuffle(diff_pairs)\n",
    "    valid_same_len = int(validation_rate * len(same_pairs))\n",
    "    valid_diff_len = int(validation_rate * len(diff_pairs))\n",
    "    valid_set = np.concatenate([same_pairs[:valid_same_len,:],\\\n",
    "                               diff_pairs[:valid_diff_len,:]], axis = 0)\n",
    "    train_set = np.concatenate([same_pairs[valid_same_len:,:],\\\n",
    "                               diff_pairs[valid_diff_len:,:]], axis = 0)\n",
    "    # shuffle again for creating the final sets\n",
    "    np.random.shuffle(train_set)\n",
    "    np.random.shuffle(valid_set)\n",
    "    return train_set, valid_set\n",
    "\n",
    "def SameDiffSep(all_pairs):\n",
    "    \"\"\"\n",
    "    Function:\n",
    "        Seperate the current set into same face set and different face set.\n",
    "    \"\"\"\n",
    "    same_pairs = all_pairs[all_pairs[:, 2] == 1]\n",
    "    diff_pairs = all_pairs[all_pairs[:, 2] == 0]\n",
    "    return same_pairs, diff_pairs\n",
    "    \n",
    "# get all images and corresponding subset names\n",
    "train_images, train_subnames = GetAllData(sub_names_train, session_names, frame_names_train)\n",
    "test_images, test_subnames = GetAllData(sub_names_test, session_names, frame_names_test)\n",
    "# get all image pairs using index representation\n",
    "all_train_pairs = PairWithIndex(train_subnames)\n",
    "all_test_pairs = PairWithIndex(test_subnames)\n",
    "# shuffle dataset\n",
    "np.random.shuffle(all_test_pairs)\n",
    "# get same and diff set of the sets for further usage\n",
    "train_same_ind, train_diff_ind = SameDiffSep(all_train_pairs)\n",
    "test_same_ind, test_diff_ind = SameDiffSep(all_test_pairs)\n",
    "# separate the set into training set and validation set\n",
    "train_ind, valid_ind =TrainValidSep(all_train_pairs)\n",
    "\n",
    "print(\"-------------------------- dataset used for training and validation ----------------------\")\n",
    "print(\"The orginal set conatains totally \\t\", len(all_train_pairs), \"\\t pairs of images, \\nwith \\t\\t\\t\\t\\t\", \\\n",
    "      len(train_same_ind), \"\\t\\t pairs showing same faces \\nand \\t\\t\\t\\t\\t\", \\\n",
    "      len(train_diff_ind), \"\\t\\t pairs showing different faces.\")\n",
    "\n",
    "print(\"---------------------------------- dataset used for test ---------------------------------\")\n",
    "print(\"The test set conatains totally \\t\\t\", len(all_test_pairs), \"\\t\\t pairs of images, \\nwith \\t\\t\\t\\t\\t\", \\\n",
    "      len(test_same_ind), \"\\t\\t pairs showing same faces \\nand \\t\\t\\t\\t\\t\", \\\n",
    "      len(test_diff_ind), \"\\t\\t pairs showing different faces.\")\n",
    "\n",
    "print(\"----------------------------- training set and validation set ----------------------------\")\n",
    "print(\"After separation, the training set contains \\t\", len(train_ind), \"\\t pairs of images,\\\n",
    "        \\nand validation set contrains \\t\\t\\t\", len(valid_ind), \"\\t\\t pairs of images.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 64)\n"
     ]
    }
   ],
   "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",
    "train_images_new = GrayHistSobel(train_images[0])\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
}