1-preprocess.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import sys\n",
    "import tarfile\n",
    "import tensorflow as tf\n",
    "from IPython.display import Image\n",
    "from scipy import ndimage\n",
    "from six.moves.urllib.request import urlretrieve\n",
    "from six.moves import cPickle as pickle\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "url = 'http://ufldl.stanford.edu/housenumbers/'\n",
    "last_percent_reported = None\n",
    "\n",
    "\n",
    "def download_progress_hook(count, blockSize, totalSize):\n",
    "    \"\"\"\n",
    "    A hook to report the progress of a download. This is mostly intended for users with\n",
    "    slow internet connections. Reports every 1% change in download progress.\n",
    "    \"\"\"\n",
    "    global last_percent_reported\n",
    "    percent = int(count * blockSize * 100 / totalSize)\n",
    "\n",
    "    if last_percent_reported != percent:\n",
    "        if percent % 5 == 0:\n",
    "            sys.stdout.write(\"%s%%\" % percent)\n",
    "            sys.stdout.flush()\n",
    "        else:\n",
    "            sys.stdout.write(\".\")\n",
    "            sys.stdout.flush()\n",
    "\n",
    "        last_percent_reported = percent\n",
    "        \n",
    "        \n",
    "def maybe_download(filename, force=False):\n",
    "    \"\"\"\n",
    "    Download a file if not present, and make sure it's the right size.\n",
    "    \"\"\"\n",
    "    if force or not os.path.exists(filename):\n",
    "        print('Attempting to download:', filename) \n",
    "        filename, _ = urlretrieve(url + filename, filename, reporthook=download_progress_hook)\n",
    "        print('\\nDownload Complete!')\n",
    "    else:\n",
    "        print(filename, 'is already downloaded. Skipped.')\n",
    "    return filename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train.tar.gz is already downloaded. Skipped.\n"
     ]
    }
   ],
   "source": [
    "train_filename = maybe_download('train.tar.gz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test.tar.gz is already downloaded. Skipped.\n"
     ]
    }
   ],
   "source": [
    "test_filename = maybe_download('test.tar.gz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "extra.tar.gz is already downloaded. Skipped.\n"
     ]
    }
   ],
   "source": [
    "extra_filename = maybe_download('extra.tar.gz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.random.seed(133)\n",
    "\n",
    "\n",
    "def maybe_extract(file_, force=False):\n",
    "    filename = os.path.splitext(os.path.splitext(file_)[0])[0]  # remove .tar.gz\n",
    "    \n",
    "    if os.path.isdir(filename) and not force:\n",
    "        # You may override by setting force=True.\n",
    "        print('%s is already presented - Skipping extraction of %s.' % (filename, file_))\n",
    "    else:\n",
    "        print('Extracting %s file data. Please wait...' % file_)\n",
    "        tar = tarfile.open(file_)\n",
    "        sys.stdout.flush()\n",
    "        tar.extractall()\n",
    "        tar.close()\n",
    "        print('File %s is successfully extracted into %s directory.' % (file_, filename))        \n",
    "    \n",
    "    return filename"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting train.tar.gz file data. Please wait...\n",
      "File train.tar.gz is successfully extracted into train directory.\n"
     ]
    }
   ],
   "source": [
    "# Variables contain directory names where data is extracted\n",
    "train_folder = maybe_extract(train_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting test.tar.gz file data. Please wait...\n",
      "File test.tar.gz is successfully extracted into test directory.\n"
     ]
    }
   ],
   "source": [
    "test_folder = maybe_extract(test_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting extra.tar.gz file data. Please wait...\n",
      "File extra.tar.gz is successfully extracted into extra directory.\n"
     ]
    }
   ],
   "source": [
    "extra_folder = maybe_extract(extra_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def remove_anomaly_samples(data, max_class_length = 5):\n",
    "    \"\"\"\n",
    "    Here we remove all data which has class length higher than specified value.\n",
    "    \"\"\"\n",
    "    print(\"\\nDataset size before update:\", len(data))\n",
    "    \n",
    "    for i in range(len(data)):\n",
    "        if i < len(data) and len(data[i]['label']) > max_class_length:\n",
    "            print(\"\\nAnomaly at index %d detected. Class size: %d\" % (i, len(data[i]['label'])))\n",
    "            del data[i]\n",
    "            \n",
    "    print(\"\\nDataset after before update:\", len(data))            \n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import h5py\n",
    "\n",
    "# The DigitStructFile is just a wrapper around the h5py data.  It basically references \n",
    "#     file_:            The input h5 matlab file\n",
    "#     digitStructName   The h5 ref to all the file names\n",
    "#     digitStructBbox   The h5 ref to all struc data\n",
    "class DigitStructsWrapper:\n",
    "    def __init__(self, file_, start_ = 0, end_ = 0):\n",
    "        self.file_ = h5py.File(file_, 'r')\n",
    "        self.names = self.file_['digitStruct']['name'][start_:end_] if end_ > 0 else self.file_['digitStruct']['name']\n",
    "        self.bboxes = self.file_['digitStruct']['bbox'][start_:end_] if end_ > 0 else self.file_['digitStruct']['bbox']\n",
    "        self.collectionSize = len(self.names)\n",
    "        print(\"\\n%s file structure contain %d entries\" % (file_, self.collectionSize))\n",
    "        \n",
    "        \n",
    "    def bboxHelper(self, keys_):\n",
    "        \"\"\"\n",
    "        Method handles the coding difference when there is exactly one bbox or an array of bbox. \n",
    "        \"\"\"\n",
    "        if (len(keys_) > 1):\n",
    "            val = [self.file_[keys_.value[j].item()].value[0][0] for j in range(len(keys_))]\n",
    "        else:\n",
    "            val = [keys_.value[0][0]]\n",
    "        return val\n",
    "\n",
    "    \n",
    "    # getBbox returns a dict of data for the n(th) bbox. \n",
    "    def getBbox(self, n):\n",
    "        bbox = {}\n",
    "        bb = self.bboxes[n].item()\n",
    "        bbox['height'] = self.bboxHelper(self.file_[bb][\"height\"])\n",
    "        bbox['left'] = self.bboxHelper(self.file_[bb][\"left\"])\n",
    "        bbox['top'] = self.bboxHelper(self.file_[bb][\"top\"])\n",
    "        bbox['width'] = self.bboxHelper(self.file_[bb][\"width\"])\n",
    "        bbox['label'] = self.bboxHelper(self.file_[bb][\"label\"])\n",
    "        return bbox\n",
    "\n",
    "    \n",
    "    def getName(self, n):\n",
    "        \"\"\"\n",
    "        Method returns the filename for the n(th) digitStruct. Since each letter is stored in a structure \n",
    "        as array of ANSII char numbers we should convert it back by calling chr function.\n",
    "        \"\"\"\n",
    "        return ''.join([chr(c[0]) for c in self.file_[self.names[n][0]].value])\n",
    "\n",
    "    \n",
    "    def getNumberStructure(self,n):\n",
    "        s = self.getBbox(n)\n",
    "        s['name']=self.getName(n)\n",
    "        return s\n",
    "\n",
    "    def getAllNumbersStructure(self):\n",
    "        \"\"\"\n",
    "        Method returns an array, which contains information about every image.\n",
    "        This info contains: positions, labels \n",
    "        \"\"\"\n",
    "        return [self.getNumberStructure(i) for i in range(self.collectionSize)]\n",
    "\n",
    "    \n",
    "    # Return a restructured version of the dataset (one object per digit in 'boxes').\n",
    "    #\n",
    "    #   Return a list of dicts :\n",
    "    #      'filename' : filename of the samples\n",
    "    #      'boxes' : list of dicts (one by digit) :\n",
    "    #          'label' : 1 to 9 corresponding digits. 10 for digit '0' in image.\n",
    "    #          'left', 'top' : position of bounding box\n",
    "    #          'width', 'height' : dimension of bounding box\n",
    "    #\n",
    "    # Note: We may turn this to a generator, if memory issues arise.\n",
    "    def getAllNumbersRestructured(self): # getAllDigitStructure_ByDigit\n",
    "        numbersData = self.getAllNumbersStructure()\n",
    "        print(\"\\nObject structure before transforming: \", numbersData[0])\n",
    "        remove_anomaly_samples(numbersData)\n",
    "        \n",
    "        result = []\n",
    "        for numData in numbersData:\n",
    "            metadatas = []\n",
    "            for i in range(len(numData['height'])):\n",
    "                metadata = {}\n",
    "                metadata['height'] = numData['height'][i]\n",
    "                metadata['label']  = numData['label'][i]\n",
    "                metadata['left']   = numData['left'][i]\n",
    "                metadata['top']    = numData['top'][i]\n",
    "                metadata['width']  = numData['width'][i]\n",
    "                metadatas.append(metadata)\n",
    "                \n",
    "            result.append({ 'boxes':metadatas, 'name':numData[\"name\"] })\n",
    "            \n",
    "        print(\"\\nObject structure after transforming: \", result[0])\n",
    "        \n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "train/digitStruct.mat file structure contain 33402 entries\n",
      "\n",
      "Object structure before transforming:  {'name': '1.png', 'top': [77.0, 81.0], 'label': [1.0, 9.0], 'width': [81.0, 96.0], 'height': [219.0, 219.0], 'left': [246.0, 323.0]}\n",
      "\n",
      "Dataset size before update: 33402\n",
      "\n",
      "Anomaly at index 29929 detected. Class size: 6\n",
      "\n",
      "Dataset after before update: 33401\n",
      "\n",
      "Object structure after transforming:  {'boxes': [{'width': 81.0, 'top': 77.0, 'label': 1.0, 'left': 246.0, 'height': 219.0}, {'width': 96.0, 'top': 81.0, 'label': 9.0, 'left': 323.0, 'height': 219.0}], 'name': '1.png'}\n"
     ]
    }
   ],
   "source": [
    "file_ = os.path.join(train_folder, 'digitStruct.mat')\n",
    "dsf = DigitStructsWrapper(file_)\n",
    "train_data = dsf.getAllNumbersRestructured()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "test/digitStruct.mat file structure contain 13068 entries\n",
      "\n",
      "Object structure before transforming:  {'name': '1.png', 'top': [7.0], 'label': [5.0], 'width': [19.0], 'height': [30.0], 'left': [43.0]}\n",
      "\n",
      "Dataset size before update: 13068\n",
      "\n",
      "Dataset after before update: 13068\n",
      "\n",
      "Object structure after transforming:  {'boxes': [{'width': 19.0, 'top': 7.0, 'label': 5.0, 'left': 43.0, 'height': 30.0}], 'name': '1.png'}\n"
     ]
    }
   ],
   "source": [
    "file_ = os.path.join(test_folder, 'digitStruct.mat')\n",
    "dsf = DigitStructsWrapper(file_)\n",
    "test_data = dsf.getAllNumbersRestructured()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "extra/digitStruct.mat file structure contain 50000 entries\n",
      "\n",
      "Object structure before transforming:  {'name': '1.png', 'top': [70.0, 41.0, 23.0], 'label': [4.0, 7.0, 8.0], 'width': [38.0, 36.0, 47.0], 'height': [56.0, 56.0, 56.0], 'left': [24.0, 55.0, 79.0]}\n",
      "\n",
      "Dataset size before update: 50000\n",
      "\n",
      "Dataset after before update: 50000\n",
      "\n",
      "Object structure after transforming:  {'boxes': [{'width': 38.0, 'top': 70.0, 'label': 4.0, 'left': 24.0, 'height': 56.0}, {'width': 36.0, 'top': 41.0, 'label': 7.0, 'left': 55.0, 'height': 56.0}, {'width': 47.0, 'top': 23.0, 'label': 8.0, 'left': 79.0, 'height': 56.0}], 'name': '1.png'}\n"
     ]
    }
   ],
   "source": [
    "file_ = os.path.join(extra_folder, 'digitStruct.mat')\n",
    "dsf = DigitStructsWrapper(file_, 0, 50000)\n",
    "extra_data = dsf.getAllNumbersRestructured()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "\n",
    "def print_data_stats(data, folder):\n",
    "    data_imgSize = np.ndarray([len(data),2])\n",
    "\n",
    "    for i in np.arange(len(data)):\n",
    "        filename = data[i]['name']\n",
    "        filepath = os.path.join(folder, filename)\n",
    "        data_imgSize[i, :] = Image.open(filepath).size[:]\n",
    "\n",
    "    max_w, max_h = np.amax(data_imgSize[:,0]), np.amax(data_imgSize[:,1])\n",
    "    min_w, min_h = np.amin(data_imgSize[:,0]), np.amin(data_imgSize[:,1])\n",
    "    mean_w, mean_h = np.mean(data_imgSize[:,0]), np.mean(data_imgSize[:,1])\n",
    "    print(folder, \"max width and height:\", max_w, max_h) \n",
    "    print(folder, \"min width and height:\", min_w, min_h)\n",
    "    print(folder, \"mean width and height:\", mean_w, mean_h, \"\\n\")\n",
    "    \n",
    "    max_w_i, max_h_i = np.where(data_imgSize[:,0] == max_w), np.where(data_imgSize[:,1] == max_h)\n",
    "    print(folder, \"max width indicies:\", max_w_i) \n",
    "    print(folder, \"max height indicies:\", max_h_i, \"\\n\")\n",
    "    \n",
    "    \n",
    "    min_w_i, min_h_i = np.where(data_imgSize[:,0] == min_w), np.where(data_imgSize[:,1] == min_h)\n",
    "    print(folder, \"min width indicies:\", min_w_i) \n",
    "    print(folder, \"min height indicies:\", min_h_i, \"\\n***\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train max width and height: 876.0 501.0\n",
      "train min width and height: 25.0 12.0\n",
      "train mean width and height: 128.286338732 57.2139456902 \n",
      "\n",
      "train max width indicies: (array([  410,  4163, 15855, 30483]),)\n",
      "train max height indicies: (array([15855]),) \n",
      "\n",
      "train min width indicies: (array([9747]),)\n",
      "train min height indicies: (array([ 1813,  2291,  4829,  5691,  9488,  9747,  9831, 10175, 10938,\n",
      "       14902, 16284, 20314, 20775, 21544, 22330, 24015, 25438, 26047,\n",
      "       26345, 27062, 27160, 27593, 27959, 29526, 29701, 30064, 30089,\n",
      "       30462, 30947, 32339, 32351, 32539, 32567, 33141, 33180, 33202]),) \n",
      "***\n",
      "\n",
      "test max width and height: 1083.0 516.0\n",
      "test min width and height: 31.0 13.0\n",
      "test mean width and height: 172.583486379 71.5664983165 \n",
      "\n",
      "test max width indicies: (array([ 1722,  2949,  6233, 12862]),)\n",
      "test max height indicies: (array([14]),) \n",
      "\n",
      "test min width indicies: (array([  459,  5352,  7776, 11257, 12191]),)\n",
      "test min height indicies: (array([ 145, 1591, 5352, 7776]),) \n",
      "***\n",
      "\n",
      "extra max width and height: 668.0 356.0\n",
      "extra min width and height: 22.0 13.0\n",
      "extra mean width and height: 100.04358 60.72528 \n",
      "\n",
      "extra max width indicies: (array([32352]),)\n",
      "extra max height indicies: (array([43845]),) \n",
      "\n",
      "extra min width indicies: (array([19731, 25534]),)\n",
      "extra min height indicies: (array([ 9662, 26875, 27476, 42560, 49492]),) \n",
      "***\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print_data_stats(train_data, train_folder)\n",
    "print_data_stats(test_data, test_folder)\n",
    "print_data_stats(extra_data, extra_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "img_size = 32\n",
    "\n",
    "def prepare_images(samples, folder):\n",
    "    print(\"Started preparing images for convnet...\")\n",
    "    \n",
    "    prepared_images = np.ndarray([len(samples),img_size,img_size,1], dtype='float32')\n",
    "    actual_numbers = np.ones([len(samples),6], dtype=int) * 10\n",
    "    files = []\n",
    "    for i in range(len(samples)):\n",
    "        filename = samples[i]['name']\n",
    "        filepath = os.path.join(folder, filename)\n",
    "        image = Image.open(filepath)\n",
    "        boxes = samples[i]['boxes']\n",
    "        number_length = len(boxes)\n",
    "        files.append(filename)\n",
    "        \n",
    "        # at 0 index we store length of a label. 3 -> 1; 123-> 3, 12543 -> 5\n",
    "        actual_numbers[i,0] = number_length\n",
    "        \n",
    "        top = np.ndarray([number_length], dtype='float32')\n",
    "        left = np.ndarray([number_length], dtype='float32')\n",
    "        height = np.ndarray([number_length], dtype='float32')\n",
    "        width = np.ndarray([number_length], dtype='float32')\n",
    "        \n",
    "        for j in range(number_length):\n",
    "            # here we use j+1 since first entry used by label length\n",
    "            actual_numbers[i,j+1] = boxes[j]['label']\n",
    "            if boxes[j]['label'] == 10: # Replacing 10 with 0\n",
    "                actual_numbers[i,j+1] = 0\n",
    "                \n",
    "            top[j] = boxes[j]['top']\n",
    "            left[j] = boxes[j]['left']\n",
    "            height[j] = boxes[j]['height']\n",
    "            width[j] = boxes[j]['width']\n",
    "        \n",
    "        img_min_top = np.amin(top)\n",
    "        img_min_left = np.amin(left)\n",
    "        img_height = np.amax(top) + height[np.argmax(top)] - img_min_top\n",
    "        img_width = np.amax(left) + width[np.argmax(left)] - img_min_left\n",
    "\n",
    "        img_left = np.floor(img_min_left - 0.1 * img_width)\n",
    "        img_top = np.floor(img_min_top - 0.1 * img_height)\n",
    "        img_right = np.amin([np.ceil(img_left + 1.2 * img_width), image.size[0]])\n",
    "        img_bottom = np.amin([np.ceil(img_top + 1.2 * img_height), image.size[1]])\n",
    "            \n",
    "        image = image.crop((img_left, img_top, img_right, img_bottom)).resize([img_size, img_size], Image.ANTIALIAS) # Resize image to 32x32\n",
    "        image = np.dot(np.array(image, dtype='float32'), [[0.2989],[0.5870],[0.1140]]) # Convert image to the grayscale\n",
    "\n",
    "        mean = np.mean(image, dtype='float32')\n",
    "        std = np.std(image, dtype='float32', ddof=1)\n",
    "        if std < 0.0001: \n",
    "            std = 1.0\n",
    "        image = (image - mean) / std\n",
    "        prepared_images[i,:,:] = image[:,:,:]\n",
    "        \n",
    "    print(\"Completed. Images cropped, resized and grayscaled\")\n",
    "    \n",
    "    return prepared_images, actual_numbers, files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started preparing images for convnet...\n",
      "Completed. Images cropped, resized and grayscaled\n",
      "(33401, 32, 32, 1) (33401, 6)\n"
     ]
    }
   ],
   "source": [
    "train_data, train_labels, _ = prepare_images(train_data, train_folder)\n",
    "print(train_data.shape, train_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started preparing images for convnet...\n",
      "Completed. Images cropped, resized and grayscaled\n",
      "(13068, 32, 32, 1) (13068, 6)\n"
     ]
    }
   ],
   "source": [
    "test_data, test_labels, test_filenames = prepare_images(test_data, test_folder)\n",
    "print(test_data.shape, test_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started preparing images for convnet...\n",
      "Completed. Images cropped, resized and grayscaled\n",
      "(50000, 32, 32, 1) (50000, 32, 32, 1)\n"
     ]
    }
   ],
   "source": [
    "extra_data, extra_labels, _ = prepare_images(extra_data, extra_folder)\n",
    "print(extra_data.shape, extra_data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3  4  7  8 10 10]\n",
      " [ 2  7  1 10 10 10]\n",
      " [ 3  1  7  4 10 10]\n",
      " [ 2  3  0 10 10 10]\n",
      " [ 3  2  8  8 10 10]\n",
      " [ 2  3  1 10 10 10]\n",
      " [ 3  1  7  0 10 10]\n",
      " [ 2  8  1 10 10 10]\n",
      " [ 2  5  6 10 10 10]\n",
      " [ 3  4  4  4 10 10]]\n"
     ]
    }
   ],
   "source": [
    "print(extra_labels[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Train shapes: (73401, 32, 32, 1) (73401, 6)\n",
      "Extra shapes: (10000, 32, 32, 1) (10000, 6)\n",
      "Test shapes: (13068, 32, 32, 1) (13068, 6)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.utils import shuffle\n",
    "\n",
    "# Here we add new data to our training set from extra set.\n",
    "# Then we remove this part from memory to free it\n",
    "train_data_temp = np.concatenate((train_data, extra_data[:40000, :, :, :]))\n",
    "extra_data_temp = np.delete(extra_data, np.arange(40000), axis=0)\n",
    "\n",
    "train_labels_temp = np.concatenate((train_labels, extra_labels[:40000]))\n",
    "extra_labels_temp = np.delete(extra_labels, np.arange(40000), axis=0)\n",
    "\n",
    "# And then we shuffle all the data we have\n",
    "train_data_temp, train_labels_temp = shuffle(train_data_temp, train_labels_temp)\n",
    "extra_data_temp, extra_labels_temp = shuffle(extra_data_temp, extra_labels_temp)\n",
    "test_data_temp, test_labels_temp, test_filenames_temp = shuffle(test_data, test_labels, test_filenames)\n",
    "\n",
    "print(\"\\nTrain shapes:\", train_data_temp.shape, train_labels_temp.shape)\n",
    "print(\"Extra shapes:\", extra_data_temp.shape, extra_labels_temp.shape)\n",
    "print(\"Test shapes:\", test_data_temp.shape, test_labels_temp.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compressed pickle size: 399965309\n"
     ]
    }
   ],
   "source": [
    "pickle_file = 'SVHN.pickle'\n",
    "\n",
    "try:\n",
    "    f = open(pickle_file, 'wb')\n",
    "    save = {\n",
    "        'train_data': train_data_temp,\n",
    "        'train_labels': train_labels_temp,\n",
    "        'test_data': test_data_temp,\n",
    "        'test_labels': test_labels_temp,\n",
    "        'test_filenames': test_filenames_temp,\n",
    "        'valid_data': extra_data_temp, # The rest of extra data will be used \n",
    "        'valid_labels': extra_labels_temp # as validation set during model training\n",
    "        }\n",
    "    pickle.dump(save, f, pickle.HIGHEST_PROTOCOL)\n",
    "    f.close()\n",
    "except Exception as e:\n",
    "    print('Unable to save data to', pickle_file, ':', e)\n",
    "    raise\n",
    "    \n",
    "statinfo = os.stat(pickle_file)\n",
    "print('Compressed pickle size:', statinfo.st_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "train_num_length = Counter(train_labels_temp[:,0])\n",
    "test_num_length = Counter(test_labels_temp[:,0])\n",
    "extra_num_length = Counter(extra_labels_temp[:,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEZCAYAAAC5AHPcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIfRJVCAhhBD6JCqQEEIIffL/AA1pE4dtkTwIAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1131cd890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(1)\n",
    "\n",
    "plt.subplot(221)\n",
    "plt.bar(train_num_length.keys(), train_num_length.values(), align='center')\n",
    "plt.xticks(train_num_length.keys())\n",
    "plt.title('Train')\n",
    "plt.xlabel('Labels')\n",
    "plt.ylabel('Occurencies')\n",
    "\n",
    "plt.subplot(222)\n",
    "plt.bar(test_num_length.keys(), test_num_length.values(), align='center')\n",
    "plt.xticks(test_num_length.keys())\n",
    "plt.title('Test')\n",
    "plt.xlabel('Labels')\n",
    "plt.ylabel('Occurencies')\n",
    "\n",
    "plt.subplot(223)\n",
    "plt.bar(extra_num_length.keys(), extra_num_length.values(), align='center')\n",
    "plt.xticks(test_num_length.keys())\n",
    "plt.title('Extra')\n",
    "plt.xlabel('Labels')\n",
    "plt.ylabel('Occurencies')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pickle_file = 'SVHN.pickle'\n",
    "\n",
    "with open(pickle_file, 'rb') as f:\n",
    "    save = pickle.load(f)\n",
    "    train_labels = save['train_labels']\n",
    "    test_labels = save['test_labels']\n",
    "    valid_labels = save['valid_labels']\n",
    "    del save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "# Remove classes of empty labels\n",
    "train_digits = Counter(train_labels.flatten()[np.where(train_labels.flatten() != 10)])\n",
    "test_digits = Counter(test_labels.flatten()[np.where(test_labels.flatten() != 10)])\n",
    "valid_digits = Counter(valid_labels.flatten()[np.where(valid_labels.flatten() != 10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ0AAAFRCAYAAADeotwvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x111576510>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "f, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 5))\n",
    "\n",
    "ax1.bar(train_digits.keys(), train_digits.values(), align='center')\n",
    "ax1.set_xticks(train_digits.keys())\n",
    "ax1.set_title('Train')\n",
    "ax1.set_xlabel('Labels')\n",
    "ax1.set_ylabel('Occurencies')\n",
    "\n",
    "ax2.bar(test_digits.keys(), test_digits.values(), align='center')\n",
    "ax2.set_xticks(test_digits.keys())\n",
    "ax2.set_title('Test')\n",
    "ax2.set_xlabel('Labels')\n",
    "ax2.set_ylabel('Occurencies')\n",
    "\n",
    "ax3.bar(valid_digits.keys(), valid_digits.values(), align='center')\n",
    "ax3.set_xticks(valid_digits.keys())\n",
    "ax3.set_title('Validation')\n",
    "ax3.set_xlabel('Labels')\n",
    "ax3.set_ylabel('Occurencies')\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}