data_preprocessing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ASL Handshape Data\n",
    "\n",
    "## Description of data\n",
    "Link to data found on Nicolas Pugeault's website\n",
    "(http://empslocal.ex.ac.uk/people/staff/np331/index.php?section=FingerSpellingDataset). The dataset is of 24 static handshapes corresponding to English letters (excluding the letters \"J\" and \"Z\" since they require motion). The data comprises of 5 different non-native signers of about 60,000 RGB (intensity) images and depth images. The images have some rotational variance as the subject moved their hand during the image capture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook setup\n",
    "\n",
    "Run this section if data is already partially processed "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import re\n",
    "import sys\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image \n",
    "from functools import reduce\n",
    "\n",
    "## Variables needed for reference throughout sections\n",
    "dataset_url = 'www.cvssp.org/FingerSpellingKinect2011/fingerspelling5.tar.bz2'\n",
    "filename = 'fingerspelling5.tar.bz2'\n",
    "# Data directory\n",
    "final_data_dir = 'data'\n",
    "# Data's top-level directory (after download & decompreshion)\n",
    "dataset_dir = 'dataset5'\n",
    "# Filename for image sizes\n",
    "img_sizes_csv = 'image_sizes.csv' "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grabbing data\n",
    "\n",
    "Below is a script to download the data to the local machine. Note that compressed file is over 2GB. If the data was already retrieved, you can skip this section and start with the preprocessing the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Link to dataset and \n",
    "os.system('wget {URL}'.format(URL=dataset_url))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Uncompress\n",
    "os.system('tar xjf {}'.format(filename))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing and relabelling data\n",
    "\n",
    "Only RGB image data is needed and should be relabelled so that the files can be easily be placed into one directory but still contain metadata for classification, validation, and testing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1502: datas/07_0_0425.png renamed from dataset5/B/h/color_7_0425.pngg"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#4327: Depth file deleted dataset5/B/m/depth_12_0497.pngor_12_0039.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#7141: Depth file deleted dataset5/B/y/depth_24_0011.pngor_24_0302.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#9975: Depth file deleted dataset5/B/p/depth_15_0315.pngor_15_0255.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#12623: datas/21_0_0351.png renamed from dataset5/B/v/color_21_0351.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#15240: datas/07_1_0179.png renamed from dataset5/A/h/color_7_0179.pngg"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#19564: Depth file deleted dataset5/A/o/depth_14_0465.pngor_14_0115.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#24558: datas/10_1_0034.png renamed from dataset5/A/k/color_10_0034.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#29042: datas/22_2_0037.png renamed from dataset5/C/w/color_22_0037.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#34145: Depth file deleted dataset5/C/f/depth_5_0221.pnglor_5_0287.pngg"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#38891: Depth file deleted dataset5/C/i/depth_8_0028.pnglor_8_0351.pngg"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#44359: datas/16_3_0158.png renamed from dataset5/D/q/color_16_0158.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#50156: Depth file deleted dataset5/D/l/depth_11_0372.pngor_11_0340.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#55404: Depth file deleted dataset5/E/w/depth_22_0148.pngor_22_0174.png"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#60912: datas/06_4_0037.png renamed from dataset5/E/g/color_6_0037.pngg"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#65735: datas/13_4_0408.png renamed from dataset5/E/n/color_13_0408.png"
     ]
    }
   ],
   "source": [
    "# Make a new data directory if doesn't exist\n",
    "if not os.path.exists(final_data_dir):\n",
    "    os.makedirs(final_data_dir)\n",
    "\n",
    "# Define patterns for depth files & RGB files \n",
    "# Format: `depth_0_0528.png` & `color_12_0137.png`\n",
    "pattern_depth_file = '(depth\\w*.png)'\n",
    "pattern_rgb_file = 'color_\\d*_(\\d*).png'\n",
    "# Number of files renamed/delted\n",
    "n_del, n_rename = 0,0\n",
    "\n",
    "# Save that this is a new subject (numerical since letter can be confusing)\n",
    "# Each subject in directory with a letter ('A','B','C',...)\n",
    "for (subject_id, subject_dir) in enumerate(os.listdir(dataset_dir)):\n",
    "    # Directories for each letter (excluding \"j\" & \"z\")\n",
    "    path_to_subject = os.path.join(dataset_dir, subject_dir)\n",
    "    \n",
    "    for letter_dir in os.listdir(path_to_subject):\n",
    "        # Use letter as number ('a' starts @ 00)\n",
    "        letter_id = ord(letter_dir.lower()) - ord(('a'))\n",
    "        letter_id = '0{}'.format(letter_id) if letter_id < 10 else letter_id\n",
    "        path_to_letter = os.path.join(path_to_subject, letter_dir)\n",
    "        \n",
    "        for image_file in os.listdir(path_to_letter):\n",
    "            # Remove depth file\n",
    "            if re.search(pattern_depth_file, image_file):\n",
    "                path_depth_file = os.path.join(path_to_letter, image_file)\n",
    "                os.remove(path_depth_file)\n",
    "                # Inform depth file removed\n",
    "                print('\\r#{}: Depth file deleted {}'.format(n_del,path_depth_file), end='')\n",
    "                n_del += 1\n",
    "            else:\n",
    "                # Get ID of each file (None if not matched)\n",
    "                num_id = re.match(pattern_rgb_file, image_file)\n",
    "                if num_id:\n",
    "                    # Get the matching parathesis only\n",
    "                    num_id = num_id.group(1)\n",
    "                    path_image_file = os.path.join(path_to_letter, image_file)\n",
    "                    # Rename image\n",
    "                    new_image_name = '{}_{}_{}.png'.format(letter_id,subject_id,num_id)\n",
    "                    new_path_image_file = os.path.join(final_data_dir, new_image_name)\n",
    "                    os.rename(path_image_file, new_path_image_file)\n",
    "                    # Inform image renamed\n",
    "                    print('\\r#{}: {} renamed from {}'.format(n_rename,new_path_image_file,path_image_file), end='')\n",
    "                    n_rename += 1\n",
    "            sys.stdout.flush()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploring image size\n",
    "\n",
    "The next step would be to make all images the same size, however it is unclear what are the images' current sizes. So a quick exploration will done to determine how the images will be resized (and padded if needed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create headers for dataframe columns\n",
    "img_dict = {'filename':[], 'width':[], 'height':[]}\n",
    "\n",
    "# Get only relevant files\n",
    "file_list = [x for x in os.listdir(final_data_dir) if re.search('\\w*png', x)]\n",
    "for img_filename in file_list:\n",
    "    # Open up the image file and get relevant info\n",
    "    img_path = os.path.join(final_data_dir, img_filename)\n",
    "    img = Image.open(img_path)\n",
    "    width, height = img.size\n",
    "    # Add it to a dictionary before converting to dataframe\n",
    "    img_dict['filename'].append(img_filename)\n",
    "    img_dict['width'].append(width)\n",
    "    img_dict['height'].append(height)\n",
    "    \n",
    "# Convert to dataframe and save to CSV    \n",
    "img_df = pd.DataFrame(data=img_dict)\n",
    "img_df.to_csv(img_sizes_csv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load in CSV to df if continuing\n",
    "img_df = pd.read_csv(img_sizes_csv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating some new variables to get better idea of images\n",
    "img_df['area'] = img_df.apply(lambda row: row.width * row.height, axis=1)\n",
    "img_df['aspect'] = img_df.apply(lambda row: row.width / row.height, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Number of images')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "ax = img_df['height'].hist(bins=100)\n",
    "\n",
    "ax.set_title('Distribution of Images\\' Heights')\n",
    "ax.set_xlabel('Height of image (in pixels)')\n",
    "ax.set_ylabel('Number of images')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Number of images')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "ax = img_df['width'].hist(bins=100)\n",
    "\n",
    "ax.set_title('Distribution of Images\\' Widths')\n",
    "ax.set_xlabel('Width of image (in pixels)')\n",
    "ax.set_ylabel('Number of images')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Number of images')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# Observing the total pixel area\n",
    "ax = img_df['area'].hist(bins=100)\n",
    "\n",
    "ax.set_title('Distribution of Images\\' Area')\n",
    "ax.set_xlabel('Height of image (in pixels*pixels)')\n",
    "ax.set_ylabel('Number of images')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Number of images')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# Observing the pixel aspect ratio\n",
    "ax = img_df['aspect'].hist(bins=100)\n",
    "\n",
    "ax.set_title('Distribution of Images\\' Aspect Ratio')\n",
    "ax.set_xlabel('Aspect ratio of image (width / height)')\n",
    "ax.set_ylabel('Number of images')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Unnamed: 0</th>\n",
       "      <th>height</th>\n",
       "      <th>width</th>\n",
       "      <th>area</th>\n",
       "      <th>aspect</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>65774.00000</td>\n",
       "      <td>65774.000000</td>\n",
       "      <td>65774.00000</td>\n",
       "      <td>65774.000000</td>\n",
       "      <td>65774.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>32886.50000</td>\n",
       "      <td>143.769103</td>\n",
       "      <td>103.16952</td>\n",
       "      <td>14847.704260</td>\n",
       "      <td>0.741979</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>18987.46264</td>\n",
       "      <td>23.951306</td>\n",
       "      <td>31.83872</td>\n",
       "      <td>5443.550522</td>\n",
       "      <td>0.282801</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.00000</td>\n",
       "      <td>64.000000</td>\n",
       "      <td>64.00000</td>\n",
       "      <td>4160.000000</td>\n",
       "      <td>0.368421</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>16443.25000</td>\n",
       "      <td>129.000000</td>\n",
       "      <td>78.00000</td>\n",
       "      <td>11005.750000</td>\n",
       "      <td>0.537313</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>32886.50000</td>\n",
       "      <td>144.000000</td>\n",
       "      <td>93.00000</td>\n",
       "      <td>13580.000000</td>\n",
       "      <td>0.649007</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>49329.75000</td>\n",
       "      <td>159.000000</td>\n",
       "      <td>123.00000</td>\n",
       "      <td>17375.000000</td>\n",
       "      <td>0.872549</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>65773.00000</td>\n",
       "      <td>272.000000</td>\n",
       "      <td>249.00000</td>\n",
       "      <td>55458.000000</td>\n",
       "      <td>2.460526</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Unnamed: 0        height        width          area        aspect\n",
       "count  65774.00000  65774.000000  65774.00000  65774.000000  65774.000000\n",
       "mean   32886.50000    143.769103    103.16952  14847.704260      0.741979\n",
       "std    18987.46264     23.951306     31.83872   5443.550522      0.282801\n",
       "min        0.00000     64.000000     64.00000   4160.000000      0.368421\n",
       "25%    16443.25000    129.000000     78.00000  11005.750000      0.537313\n",
       "50%    32886.50000    144.000000     93.00000  13580.000000      0.649007\n",
       "75%    49329.75000    159.000000    123.00000  17375.000000      0.872549\n",
       "max    65773.00000    272.000000    249.00000  55458.000000      2.460526"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image sizes observations\n",
    "\n",
    "Looking at our images different sizes, one can pick up on some patterns in the data. First the smallest the height or width each goes down is $64$ pixels while the maximums go to over about $270$ and $250$ pixels for height and width respectively. Height is roughly a normal curve centered near $145$ pixels while width is skewed towards smaller values with an average of about $100$ pixels.\n",
    "\n",
    "Aspect ratio and area metrics were also created from the data. The area gives us literally how many inputs there would be for the model if we simply input the pixels. The aspect ratio gives the relative size of height and width.\n",
    "\n",
    "One can notice that the aspect ratio trends below $1.0$ meaning that most images are taller than they are wide. This makes sense since the images likely capture part of the arm which for most signs creates a more vertical image. Less than $25\\%$ of all images have an aspect ratio above the $1.0$ which corresponds with images wider than they are tall.\n",
    "\n",
    "One can also notice that the area metric is heavily skewed toward smaller values. This fits with the aspect ratio and likely is because of the skew in width. The average number of pixels in the images is about $15000$ pixels and less than $25\\%$ have more than $18000$ pixels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determinig image resizing action\n",
    "\n",
    "Taking this information from the dataset, a procedure can be created to resize these images. Since the model will be using a convolutional neural network (CNN) architecture, the images must be fixed and benefits in being square that is the width and height must be equal. Ideally, one would like the images to keep as much information as possible during the resize but due to computing resource limits, the images shouldn't simply enlarged to fit to the maximums. Therefore, in resizing the images most images should retain most (if not all) of their information while there are fewer images losing information. Note that the images should not be cropped since they have already been cropped around the images' handshapes.\n",
    "\n",
    "From the data exploration, it can be observed that most images are taller than wide. It would then make sense that resizing the data should favor taller images since this is more common in the data. One solution is to add padding to images so that the width matches with the height. However, by adding the padding can give bias to the model if particular letters have differing aspect ratios (see the histogram plots below). In other words, the model could simply learn based on the padding instead of the handshape in the image. Thus stretching/squeezing or rescaling the image seems to be preferred even if the images will lose more information. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x72b34698e400>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346994710>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b3469bca20>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346f66d30>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346f1a080>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x72b346f1a0b8>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346eee6a0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346e989b0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346e43cc0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346e6dfd0>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x72b346de0320>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346d86940>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346db0fd0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346d616a0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346d09d30>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x72b346d3b400>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346ce3a90>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346c96160>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346cbe7f0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346c67e80>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x72b346c19550>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346bc0be0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346bf22b0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346b9a940>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x72b346b43fd0>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get the handshape from file name (convert number to letter)\n",
    "img_df['handshape'] = img_df.apply(lambda row: chr(int(row.filename[:2])+65), axis=1)\n",
    "# Plot the histograms by handshape\n",
    "img_df['aspect'].hist(by=img_df['handshape'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that it has been determined that rescaling is the best strategy, it now needs to be determined how large the rescaled images will be for the CNN architecture. It has already been said that a square image is preferred. More than $75\\%$ of the images have aspect ratios less than $1.0$ so most images can be simply rescaled to a square by changing the width. \n",
    "\n",
    "Restricting the width to $125$ pixels would keep information preserved for about $75\\%$ of the images. This seems to be a reasonable for width but height has to be considered as well. Restricting the image to $125$ pixels for height would mean information would be preserved for less than $25\\%$ of the images. This looks to be a poor tradeoff especially considering that most images are tall and therefore most pictures would lose information.\n",
    "\n",
    "Focusing on height instead, a restriction of $160$ pixels would preserve all the height information for about $75\\%$ of the images. Good so far observing how many images would preserve all its width image is over $75\\%$. This is great since most images will retain most (if not all) of their information.\n",
    "  \n",
    "In conclusion, resizing the images to be $160$ pixels by $160$ pixels will preserve most of the images' information. This size is also ideal since each dimension is divisible by $2^5$ which gives us a decently sized power of $2$. The total number of pixels for each image will be $25600$ pixels which is on the higher end but allows for a large proportion of the images to not lose information during the resize. There is a tradeoff between size and computation time so if this appears to be an issue during training, the image can be reduced farther so each dimension will be $134$ pixels giving a total number of pixels of $17956$. This would still keep over $75\\%$ of images to retain most of their information after resizing.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resizing images for model\n",
    "\n",
    "Now that it has been determined what and how the images should be resized, we perform it on the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#65774 of 65774: Resizing image `23_3_0101.png` w/ 0 errors"
     ]
    }
   ],
   "source": [
    "# Convert image to new size and save file\n",
    "def img_resize(width, height, img_file, new_name=None):\n",
    "    img_path = os.path.join(final_data_dir, img_file)\n",
    "    img = Image.open(img_path)\n",
    "    img = img.resize((width, height))\n",
    "    #\n",
    "    if new_name != None:\n",
    "        img_path = os.path.join(final_data_dir, new_name)\n",
    "    img.save(img_path)\n",
    "    \n",
    "\n",
    "# Resize height and width (pixels) (160,160) --> (224,224) for ResNet50\n",
    "new_width, new_height  = 160, 160\n",
    "\n",
    "# Keep track coverts\n",
    "n = 1\n",
    "file_list = [x for x in os.listdir(final_data_dir) if re.search('\\w*png', x)]\n",
    "n_imgs = len(file_list)\n",
    "errors_resize = []\n",
    "errors = 0\n",
    "\n",
    "# Resize all images\n",
    "for img_filename in file_list:\n",
    "    # Keep track of files that were not successfully resized\n",
    "    try:\n",
    "        # Open up the image file and resize\n",
    "        img_resize(new_width, new_height, img_filename)\n",
    "    except:\n",
    "        errors_resize.append((n,img_filename))\n",
    "        errors += 1\n",
    "    # Message out    \n",
    "    print('\\r#{} of {}: Resizing image `{}` w/ {} errors'.format(n,n_imgs,img_filename,errors), end='')   \n",
    "    n += 1\n",
    "    sys.stdout.flush()\n"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}