1_notmnist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5hIbr52I7Z7U"
   },
   "source": [
    "Deep Learning\n",
    "=============\n",
    "\n",
    "Assignment 1\n",
    "------------\n",
    "\n",
    "The objective of this assignment is to learn about simple data curation practices, and familiarize you with some of the data we'll be reusing later.\n",
    "\n",
    "This notebook uses the [notMNIST](http://yaroslavvb.blogspot.com/2011/09/notmnist-dataset.html) dataset to be used with python experiments. This dataset is designed to look like the classic [MNIST](http://yann.lecun.com/exdb/mnist/) dataset, while looking a little more like real data: it's a harder task, and the data is a lot less 'clean' than MNIST."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "apJbCsBHl-2A"
   },
   "outputs": [],
   "source": [
    "# These are all the modules we'll be using later. Make sure you can import them\n",
    "# before proceeding further.\n",
    "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",
    "from IPython.display import display, Image\n",
    "from scipy import ndimage\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from six.moves.urllib.request import urlretrieve\n",
    "from six.moves import cPickle as pickle\n",
    "\n",
    "# Config the matlotlib backend as plotting inline in IPython\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jNWGtZaXn-5j"
   },
   "source": [
    "First, we'll download the dataset to our local machine. The data consists of characters rendered in a variety of fonts on a 28x28 image. The labels are limited to 'A' through 'J' (10 classes). The training set has about 500k and the testset 19000 labelled examples. Given these sizes, it should be possible to train models quickly on any machine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "collapsed": false,
    "executionInfo": {
     "elapsed": 186058,
     "status": "ok",
     "timestamp": 1444485672507,
     "user": {
      "color": "#1FA15D",
      "displayName": "Vincent Vanhoucke",
      "isAnonymous": false,
      "isMe": true,
      "permissionId": "05076109866853157986",
      "photoUrl": "//lh6.googleusercontent.com/-cCJa7dTDcgQ/AAAAAAAAAAI/AAAAAAAACgw/r2EZ_8oYer4/s50-c-k-no/photo.jpg",
      "sessionId": "2a0a5e044bb03b66",
      "userId": "102167687554210253930"
     },
     "user_tz": 420
    },
    "id": "EYRJ4ICW6-da",
    "outputId": "0d0f85df-155f-4a89-8e7e-ee32df36ec8d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attempting to download: notMNIST_large.tar.gz\n",
      "0%....5%....10%....15%....20%....25%....30%....35%....40%....45%....50%....55%....60%....65%....70%....75%....80%....85%....90%....95%....100%\n",
      "Download Complete!\n",
      "Found and verified notMNIST_large.tar.gz\n",
      "Attempting to download: notMNIST_small.tar.gz\n",
      "0%....5%....10%....15%....20%....25%....30%....35%....40%....45%....50%....55%....60%....65%....70%....75%....80%....85%....90%....95%....100%\n",
      "Download Complete!\n",
      "Found and verified notMNIST_small.tar.gz\n"
     ]
    }
   ],
   "source": [
    "url = 'http://commondatastorage.googleapis.com/books1000/'\n",
    "last_percent_reported = None\n",
    "\n",
    "def download_progress_hook(count, blockSize, totalSize):\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",
    "def maybe_download(filename, expected_bytes, force=False):\n",
    "    \"\"\"Download a file if not present, and make sure it's the right size.\"\"\"\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",
    "    statinfo = os.stat(filename)\n",
    "    if statinfo.st_size == expected_bytes:\n",
    "        print('Found and verified', filename)\n",
    "    else:\n",
    "        raise Exception(\n",
    "          'Failed to verify ' + filename + '. Can you get to it with a browser?')\n",
    "    return filename\n",
    "\n",
    "train_filename = maybe_download('notMNIST_large.tar.gz', 247336696)\n",
    "test_filename = maybe_download('notMNIST_small.tar.gz', 8458043)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cC3p0oEyF8QT"
   },
   "source": [
    "Extract the dataset from the compressed .tar.gz file.\n",
    "This should give you a set of directories, labelled A through J."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "collapsed": false,
    "executionInfo": {
     "elapsed": 186055,
     "status": "ok",
     "timestamp": 1444485672525,
     "user": {
      "color": "#1FA15D",
      "displayName": "Vincent Vanhoucke",
      "isAnonymous": false,
      "isMe": true,
      "permissionId": "05076109866853157986",
      "photoUrl": "//lh6.googleusercontent.com/-cCJa7dTDcgQ/AAAAAAAAAAI/AAAAAAAACgw/r2EZ_8oYer4/s50-c-k-no/photo.jpg",
      "sessionId": "2a0a5e044bb03b66",
      "userId": "102167687554210253930"
     },
     "user_tz": 420
    },
    "id": "H8CBE-WZ8nmj",
    "outputId": "ef6c790c-2513-4b09-962e-27c79390c762"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data for notMNIST_large. This may take a while. Please wait.\n",
      "['notMNIST_large/A', 'notMNIST_large/B', 'notMNIST_large/C', 'notMNIST_large/D', 'notMNIST_large/E', 'notMNIST_large/F', 'notMNIST_large/G', 'notMNIST_large/H', 'notMNIST_large/I', 'notMNIST_large/J']\n",
      "Extracting data for notMNIST_small. This may take a while. Please wait.\n",
      "['notMNIST_small/A', 'notMNIST_small/B', 'notMNIST_small/C', 'notMNIST_small/D', 'notMNIST_small/E', 'notMNIST_small/F', 'notMNIST_small/G', 'notMNIST_small/H', 'notMNIST_small/I', 'notMNIST_small/J']\n"
     ]
    }
   ],
   "source": [
    "num_classes = 10\n",
    "np.random.seed(133)\n",
    "\n",
    "def maybe_extract(filename, force=False):\n",
    "    root = os.path.splitext(os.path.splitext(filename)[0])[0]  # remove .tar.gz\n",
    "    if os.path.isdir(root) and not force:\n",
    "        # You may override by setting force=True.\n",
    "        print('%s already present - Skipping extraction of %s.' % (root, filename))\n",
    "    else:\n",
    "        print('Extracting data for %s. This may take a while. Please wait.' % root)\n",
    "        tar = tarfile.open(filename)\n",
    "        sys.stdout.flush()\n",
    "        tar.extractall()\n",
    "        tar.close()\n",
    "    data_folders = [\n",
    "        os.path.join(root, d) for d in sorted(os.listdir(root))\n",
    "            if os.path.isdir(os.path.join(root, d))]\n",
    "    if len(data_folders) != num_classes:\n",
    "        raise Exception(\n",
    "          'Expected %d folders, one per class. Found %d instead.' % (\n",
    "            num_classes, len(data_folders)))\n",
    "    print(data_folders)\n",
    "    return data_folders\n",
    "  \n",
    "train_folders = maybe_extract(train_filename)\n",
    "test_folders = maybe_extract(test_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4riXK3IoHgx6"
   },
   "source": [
    "---\n",
    "Problem 1\n",
    "---------\n",
    "\n",
    "Let's take a peek at some of the data to make sure it looks sensible. Each exemplar should be an image of a character A through J rendered in a different font. Display a sample of the images that we just downloaded. Hint: you can use the package IPython.display.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/A/V29sZidzIEJhbmUgU2hhZG93LnR0Zg==.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABjklEQVR4nMWRP2hUQRCHv5nd9+6C\nnCLBRgixECxUjEUaG238AzExRRAiWmuhWAiCjVgYNK2QyiokIDY2gVSCaBEIpA1oqYFg1MK7h94d\nt7tjcZfLuyC2ftW389tlZncFxIYnTuStTjQAl9fCt/fraAJQLr2+dTynjx+5uLB8FgGEbO0UiqgA\noAKOlzaH4KESvgKSzoy3aq7+KiA+fubOfEM8JMBwafpJ+yOHV36KJTwJUBAxABKN82NvDgJgaDfc\nRXFKbpQrfQwTBlCQ1FVBIqGce7ChbqFNa6JxtF0OXZj69EOMDgvL6ZA+2GGvqw+jd2e7WhRs7+85\n9/yLM/6Kv3xk8uq9KObitZv1Yb99vyX9rfp2euh6FVDGZm54naqWT6bm7ZWs90LF7K/VyuA9fb6r\n3mflDIW4twph37T/4D+F2vuyxKCDQjqQ4ZzDgTPnem4KXuzcxg4B+NCo/j65+Z1osFZUIiI8vPI0\nZAZaH3+8mi81MwMtTj9bfNShduGFJTMzsxhsq2k979i7Y38AFeSWg91v3DAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/B/QVdlaXJkUGFydHlTVy5vdGY=.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACMklEQVR4nF2SS0iVURRG1znn9xnZ\nw1sgEj0gKakcFEUhDSIbFD0moYNoUmRE4cQwShqIiWFRQQTRMAjUQVRGEUUFYZTSA0yqgWkUaNm9\notd78T//ObuBer31TRdrb77NVgQNR6MJo9RUGAsIcv3k5Nj3vu63ofYo0DWtywQV3ugoXF60qHhV\nWWk+7kPTfe0VKClsqC+0Wned6V9xcWw0Yedt3Bdw7JYBMJo1j8R7kcv7xYlEA3V7EjIcAwAVwMFB\nCWWoTsIo8k52NYnsJQCQyOjOH92G3wUYDZEuS0IMPe06x2hKM5mHAIYXFRDOQoTxNEwIgNVvElXw\nMwNhPAVJj3MuR44fWsLwxywznYTxfLQ2/evmtziuJUwwKypJgL0ThQsHug60abnQqlxmquaBuPTg\n50/vekZEnq4kR83tVMTRX16NBOWblnq/tqXKKhVkQzo7tqTDnPW1JSXVNTdPRpmxAedFGu+Js311\ni69KGMp1suApkdPtEoqTh7SJdW5HZqcQh0jQEO6+dO5X4PXhuSMQh8gDOofagucIG/4zZ6rlmjhQ\nnGWO+RkoDMVLAZdlJsdxliiKLJ3BNjTDs1AFFOXiDSbQee8ba2MO+meOYLCr2wtxt5Op3IKvVyqa\n0UKXAjDi9YnmBV73PPsTT6ZSm+uLxZueyun/oqpXnJNMvLNedoJSUPlEJHIi4qy1kbVT1os7ggG2\nP/bivfwT+3IrBlV+tjpIu2CuLqmJb713X4v2/AUyKDUn4Hrz+QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/C/UG9seW1lckJvbGRSb21hbi5vdGY=.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABwklEQVR4nG2STUuVURSFn32ONxWy\nJvaBDRxkObBBUJjQSC5CQUgf1CBo0A9oaNEkmlkN+g19WYNoKAZBWSNpZBeirFlUCBmkRuj7nrNX\ng/teS7lruBd7sfZa2wAgysPQiZGDfT0sf2m8nFkiupqUBbouvlpXBdf3u/1Ea3KR+ju5clGUZSqL\nIrtWJmoYYBYmXSmlvLFaJtfz3RimrvsXsoUc/dNsY5E9h+sDOLk2PwrGlAop6e34tqaF7jPzKn39\nCkQmVMpdd2pYjDHGaMSbWj1NgMFfcmVdJ1b+sGicrxOBx0pKetSy3rrNAjC8LHf9PEDgf8QAhLEd\nyZynn6NvIrMDvFBW1hiRNvgmdy0PbFFtIvRi4sdquz2CtR1X5BIyenvakx+Q+c5+2imEWRxxtr3u\nyIrctbR/i93QAcAzJSU92BQfobJ6tHAp6xqxlYPFDvZe7iQQuaFS7n7rX2XG8fe6VwMCT5plz52q\nyg5HptZUanqfYep+eC6FkKMvzDYW2TU4OtTpSB2TgFm8vfXByqy1qwZggbGGXKn1mkmuN8NVLhbo\nvvS60Ab+zIxHolXHRXk4dPLYYN92fn/9ODe9oIDzF9bgCAx8RaTAAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/D/Q2xhc3Rlci1CRVRBaXRhbGljLm90Zg==.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAB9klEQVR4nD2SO2tUcRDFfzP3riEq\nBLOJmI1mCeSlIiiCtUWCjfgJbATBKp9AbCwt/A5iYRlLRRsrtTJFiiSbB0heaEx8rG6y9/7nWNzV\nKQaGX3HmHI7Rm3p9sN4YbzbH/M/exvuPi3hg4HFntj48NDTUz/85WHi0awKcD5IklUWZIiIiFdKn\nUXNwBpaLo6JMoSiLbjdJUhzrGQ7O5e8KSdWSKpqOJ8nxaAyEA9i3xbXd2twNANOJqy3Iua9CkjTf\n6AdOP1FISnqAI6YAxNHrnY7nJ9pPOyaAn+QEUzhAe8eJcOvr2flBjmwaQLbZBkAX+mVgbOPG0AgG\nYhUDjBkEsv2vuDFxqtKsIFyszs1D3JnIZQCtSpppBMHnjrsxQYCy2EJgKR+t/tkg82C8p7GDwGic\nxcDZQJ7yZqX1pQdHhzHk0ULOmSYOYq+TCYxmLRnQaRHO4PlKYw2A4BoC2N9GzlgWBsZyFYHdIoNg\nJRnOTC+tVRPkunlFAGpheGULOFJey8q+xy4D2RIOvFEpKen5SeDcCyVJZRxMmpP3jQDg3B1/W47d\nHgmHMudhK0swuVv1oleSpEhJv+fJAGa7/7pTdrvdokiSXl3vxXxP3aj6mMpCktov57zH8kvUKisG\nsLLybmETPCqopeMMoPx1uL663toCsqgYfwF/5yt5Jk5XxQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/E/UGVuIFR3ZWFrcyBPbmUgU1NpLnR0Zg==.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACOElEQVR4nF2RS0iUYRSGn3O+/58c\ntSwnJxXFoKg00RDBoiIzsDEXoUZeiBZdKAINoja1yl3QXgKxFkEktSqIkKAEI6pJvIRhiyQzIhus\n1MHb/38txjHr3T4cznneI6jvlG+X+KwJpKbMfBv+DhDclmvt1HtRv6yuPzruA5hw0e7YPbe+On3g\n9djvUBGcuB1CEDWqIJyJeR8vhhGU65QNZuEIABjCnba35VwQdRx2tXOrG5NAKPvH7FVly6UMlLLL\nIe48x0myyILXjHFZn0Z2c0MQji+V4BgRhIxR20aKImw+WpeHCnRN7UVAAtTbqEEk/9DJhgJQcOTU\nUPe7+y8n5i0h+nLLszb9ij6cRa0PIuJnNFRlzscXp8NHxzsmB4c9UGsBBFEPNHOtOzuR097TE877\n+WF2+XwBxGA9CJYEvIMUl6a2PlJ/BaL4crhmOjrwdQ40Ne7zN0aoffWsVkFcAURXMXJ77BVEHAMb\nCkuL0pDkTuNF7gZreh1r8fe1xKI/3JzRt2KX5yKLCwdwUdK6+6tA4EJBcjZ9xN7ERdg4+jgVNepy\nJJJ8RpOdK0cFefMAYwCH1kI0YbGTz0NY5dqaY2I9cJb2OCMJUSUGgOfWnUZ9MbpUXtWFXTbZEZ8v\nJoXKDlxVCDS2raignLVPjFLXiIF11ecrkCQT1K+8oZ1Pqz+9yA9lB75EF5dfkuhWfSmp0GzbZycn\nYoisbhaMAulNyL+1ggKer8adMVutwfr/Q/A9j6GsFYFk/gA9+bm2pEWj0gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/F/TENEIExpZ2h0LnR0Zg==.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABT0lEQVR4nHWSwS5DURCGvzP3XIQE\niXShjaAbjahIkyaXWFqw9whexMpDeADxDLVTIkEpIkgXbKSJCKuG5N4zNtV7tce/OsmX+WfmPwMA\nIqzX3B/Fer1iAYwrRLnIqCFVoB+BBcRt7RcOl6Y0wzBfTzFAQE21YcgWAiIWTDI5C+caJn+pw4Ik\npaKTOs7RJwHDYpBwifYzBBwR4cPrf3AVbj/FBw1zM3CDDDAsklQn1JyRiUB70LCMdq5wqW3QfVsT\nS4QcvAepmya9Ssbc8VGulTEdOtjtGAWs0eJ00+6MpC3VlMc7XVs2yuX7TdvbRG272Z3JGqoQnsQm\ns6Zod6B4tAQXcZgNNh1ovuSkjksYlLAwnNDwEEBYI3x59qQOCBE8tmXgLwEkPwtNX+qAVPJKHW8h\nsiz63fC3RCLk7s0/LFKB02/PFQCw3dqb6L/YX/0AYNCANa7//mUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/G/WWFua2VlRW5ncmF2ZWQgTm9ybWFsLnR0Zg==.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACEUlEQVR4nGWSX2jNYRyHn/fP73eO\nsw0z2zIXU2KJiaHsglqKFFGulYWdonZDudXsgsSozRYd2QUXtgt/SkstCiFLkU2RWo4pszhmYzvn\n/ePid9bO5tN797yf+n6f9xXkI6X1IIvifuqPUzYpO5XVERLSOrVh1/pcTpeWFX1+2l0/gbT5mqKi\nedDf3l0ZJ1bZcHnM+NMEEVOUtHz3Iw0IohMmfWseaupf9plfdQRKCIRQOqDrCgEStDnUe+q9Ovk6\nzFnv8d6amSlRHB9f0eQHNLPRdLYTIJXdf36zaKPLFFCBkIC2y1OHP1xLjN3HzkLPqMMDvTepGvU9\nSAoTBICu27SdHeW8QrpCmAOQTf1pNsI7/JymEICs64NVTA3Pg94DctkbVCVmfB6MrCbGCRZhJ/5H\noCeXfgvLULGZy3Oaw9XYCVQxAgBXGP1224Ps1+qw4hMA4RYlf1NifzpZKrzuPhdmh+pVzXPpED62\nL5HZy73yxjCbmvZwq5Gk92fJqw1o72BJxmcWIiStRxI9X2hQRgBojZRogdBoqYZSqR9t1K6JJjIG\n5zAebzDSyuuDFy7eWXBwnvloL6da0x3Nj49VFz5oJFeCVZfutnwsviqNViLaVgqMi4xY9fBEemTn\ns5XGeS8Q4Bwlq6PfgJWZM+uOFr+4sacq7gBqYpP9i8lLQ0gLtQfWxqf/Tm3NPgkGHg0D/wANz8yQ\nlEBy5AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/H/SWZvcm11bGEtQm9sZC5vdGY=.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABoUlEQVR4nF2Rv26TQRDEf7t3mMLi\nn/mS2InxF5uGOiU9BRLvgMQLUNHRIvFStLwAXUQUJ3YsOzjGUqSYEN8txZ4thS1nZ3dndgTNR59v\nFGucf8oAaK6/BANZQeSD3Zmt7TtegTeWzLKdKUZNSmnNMQEAYZ+7lNYcR6BPDBgTBABzACaK0XP+\nOZsaODBUyQ92EBBOsTJ54JxTFVq7CChjb0p+2C5shVaFYCwWZZKnbQSTm5kKB2QwLpeoqmrgeQvB\nmM+jcIiBcbEKyYV0MQHm8wi1r7sdPEkAYfkaE4wZEbr+lrcnWysowBBNdN28cK+MIWqx9z9eakzk\n8R4CWNqAEvzOhEin6VC8v1X+TojsRxNMpl+LltWrjwBcT4H3nua3cjnwztZmyX4okReubUQjAcQ0\n8KeMs0QOfWREWjutRpwdlNpNjrZa+hsnaCiBnZVMMp0SNehO5eGNSpr2aNeBIaZVBRi/r0qTZ3sI\npnmKabthgjFdbk5WTRPgcoFpET671TLZc+DXAvSlr7soPxD6hZ2DxQ5/Aqn5c+ukzSqSmifAP3iH\nsdMBcpyQAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/I/R2FyYW1vbmQgSVRDIEJvbGQgSXRhbGljIEJULnR0Zg==.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABXklEQVR4nGVSO0sDQRicb/eCRcBH\noSKojdZWYimIWogBQxrBxia2tgr+DfEXWItgmqikESxFQREURPBRqBAtgpHs7ljs7T2S6Y7ZmZuZ\nXcBDMP5FywTGOl4pBLSO72zyQe3eLo6QQlDu0JEkLU/misgiwvCzd7ZsRBDRGVJhPhY6LqAgOaXG\nAQ1JGl72QQCkgcQOLCE+XvuL2CVc80LH9jTyphAcBtca0M2Nfvo8hpuI8mSErdDjdSR2DYHEoAQC\nAHH2ofJxFKbajNdZhs5x0NgNrtfFkFWFklgNrvVWT8lZOr8dZ5IgyUIVOAFg0bhFXigo3PtfGm53\nl9RY8a6OzYl0Om9LlGAFgMP5i3S7Dr6H6Sq9JTc8Z/k4lLmQOG0ZNp6uqfOuESZ/gnIxc/1QWoGo\n9lsBQNV8gFJZoYzt/HqhY6caZR/B3undd/zoSNI91ddT5xs6moR01nA/KfMPApcEFy1f67sAAAAA\nSUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "notMNIST_large/J/TWFkcmlkLnR0Zg==.png\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAA0UlEQVR4nO2SMWoCURCGv3k7SWO0\nithIQLtga+M1vIS3yBVSpkmTE9jZCblBAoEgBNKELAiGWIjgvrdvLFZQMaulTf5qmI9v+IsB4KJ+\nZ4cZoADh93EkgAgI0ul3bgBEASykKduEXgtAClg4xQCoOrYmmO2Y0TaCozRHIWcw/wudLqRlyMxK\nzYhz7k9TYu7St8mPyt4WgZivYvY+vF/luvtZGIBcd6fjh48AUnGJAOYS1curaq3eaPvP5xcQQ56a\ntzEG733wWbZczKffr1+zzZU1rV1TUEkATzAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import display, Image\n",
    "import random\n",
    "#IPython.display.Image(filename = , retina=True)\n",
    "def show_rand_pic_by_cluster(folders):\n",
    "    for i in folders:\n",
    "        pics = [p for p in os.listdir(train_folders[0]) if len(p.split('.'))==2 and p.split('.')[1] == 'png']\n",
    "        if len(pics) > 0:\n",
    "            pic = pics[random.randint(0,len(pics)-1)]\n",
    "            print (os.path.join(i,pic))\n",
    "            display(Image(os.path.join(i,pic)), retina=True)\n",
    "\n",
    "show_rand_pic_by_cluster(train_folders)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PBdkjESPK8tw"
   },
   "source": [
    "Now let's load the data in a more manageable format. Since, depending on your computer setup you might not be able to fit it all in memory, we'll load each class into a separate dataset, store them on disk and curate them independently. Later we'll merge them into a single dataset of manageable size.\n",
    "\n",
    "We'll convert the entire dataset into a 3D array (image index, x, y) of floating point values, normalized to have approximately zero mean and standard deviation ~0.5 to make training easier down the road. \n",
    "\n",
    "A few images might not be readable, we'll just skip them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {
       "item_id": 30
      }
     ]
    },
    "colab_type": "code",
    "collapsed": false,
    "executionInfo": {
     "elapsed": 399874,
     "status": "ok",
     "timestamp": 1444485886378,
     "user": {
      "color": "#1FA15D",
      "displayName": "Vincent Vanhoucke",
      "isAnonymous": false,
      "isMe": true,
      "permissionId": "05076109866853157986",
      "photoUrl": "//lh6.googleusercontent.com/-cCJa7dTDcgQ/AAAAAAAAAAI/AAAAAAAACgw/r2EZ_8oYer4/s50-c-k-no/photo.jpg",
      "sessionId": "2a0a5e044bb03b66",
      "userId": "102167687554210253930"
     },
     "user_tz": 420
    },
    "id": "h7q0XhG3MJdf",
    "outputId": "92c391bb-86ff-431d-9ada-315568a19e59",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pickling notMNIST_large/A.pickle.\n",
      "notMNIST_large/A\n",
      "Could not read: notMNIST_large/A/RnJlaWdodERpc3BCb29rSXRhbGljLnR0Zg==.png : cannot identify image file 'notMNIST_large/A/RnJlaWdodERpc3BCb29rSXRhbGljLnR0Zg==.png' - it's ok, skipping.\n",
      "Could not read: notMNIST_large/A/SG90IE11c3RhcmQgQlROIFBvc3Rlci50dGY=.png : cannot identify image file 'notMNIST_large/A/SG90IE11c3RhcmQgQlROIFBvc3Rlci50dGY=.png' - it's ok, skipping.\n",
      "Could not read: notMNIST_large/A/Um9tYW5hIEJvbGQucGZi.png : cannot identify image file 'notMNIST_large/A/Um9tYW5hIEJvbGQucGZi.png' - it's ok, skipping.\n",
      "Full dataset tensor: (52912, 28, 28)\n",
      "Mean: -0.128243\n",
      "Standard deviation: 0.443109\n",
      "Pickling notMNIST_large/B.pickle.\n",
      "notMNIST_large/B\n",
      "Could not read: notMNIST_large/B/TmlraXNFRi1TZW1pQm9sZEl0YWxpYy5vdGY=.png : cannot identify image file 'notMNIST_large/B/TmlraXNFRi1TZW1pQm9sZEl0YWxpYy5vdGY=.png' - it's ok, skipping.\n",
      "Full dataset tensor: (52912, 28, 28)\n",
      "Mean: -0.0075629\n",
      "Standard deviation: 0.454487\n",
      "Pickling notMNIST_large/C.pickle.\n",
      "notMNIST_large/C\n",
      "Full dataset tensor: (52912, 28, 28)\n",
      "Mean: -0.142258\n",
      "Standard deviation: 0.439806\n",
      "Pickling notMNIST_large/D.pickle.\n",
      "notMNIST_large/D\n",
      "Could not read: notMNIST_large/D/VHJhbnNpdCBCb2xkLnR0Zg==.png : cannot identify image file 'notMNIST_large/D/VHJhbnNpdCBCb2xkLnR0Zg==.png' - it's ok, skipping.\n",
      "Full dataset tensor: (52912, 28, 28)\n",
      "Mean: -0.0573667\n",
      "Standard deviation: 0.455643\n",
      "Pickling notMNIST_large/E.pickle.\n",
      "notMNIST_large/E\n",
      "Full dataset tensor: (52912, 28, 28)\n",
      "Mean: -0.069899\n",
      "Standard deviation: 0.452942\n",
      "Pickling notMNIST_large/F.pickle.\n",
      "notMNIST_large/F\n",
      "Full dataset tensor: (52912, 28, 28)\n",
      "Mean: -0.125583\n",
      "Standard deviation: 0.44709\n",
      "Pickling notMNIST_large/G.pickle.\n",
      "notMNIST_large/G\n",
      "Full dataset tensor: (52912, 28, 28)\n",
      "Mean: -0.0945814\n",
      "Standard deviation: 0.44624\n",
      "Pickling notMNIST_large/H.pickle.\n",
      "notMNIST_large/H\n",
      "Full dataset tensor: (52912, 28, 28)\n",
      "Mean: -0.0685221\n",
      "Standard deviation: 0.454232\n",
      "Pickling notMNIST_large/I.pickle.\n",
      "notMNIST_large/I\n",
      "Full dataset tensor: (52912, 28, 28)\n",
      "Mean: 0.0307862\n",
      "Standard deviation: 0.468899\n",
      "Pickling notMNIST_large/J.pickle.\n",
      "notMNIST_large/J\n",
      "Full dataset tensor: (52911, 28, 28)\n",
      "Mean: -0.153358\n",
      "Standard deviation: 0.443656\n",
      "Pickling notMNIST_small/A.pickle.\n",
      "notMNIST_small/A\n",
      "Could not read: notMNIST_small/A/RGVtb2NyYXRpY2FCb2xkT2xkc3R5bGUgQm9sZC50dGY=.png : cannot identify image file 'notMNIST_small/A/RGVtb2NyYXRpY2FCb2xkT2xkc3R5bGUgQm9sZC50dGY=.png' - it's ok, skipping.\n",
      "Full dataset tensor: (1873, 28, 28)\n",
      "Mean: -0.132556\n",
      "Standard deviation: 0.44502\n",
      "Pickling notMNIST_small/B.pickle.\n",
      "notMNIST_small/B\n",
      "Full dataset tensor: (1873, 28, 28)\n",
      "Mean: 0.00535609\n",
      "Standard deviation: 0.457115\n",
      "Pickling notMNIST_small/C.pickle.\n",
      "notMNIST_small/C\n",
      "Full dataset tensor: (1873, 28, 28)\n",
      "Mean: -0.141521\n",
      "Standard deviation: 0.44269\n",
      "Pickling notMNIST_small/D.pickle.\n",
      "notMNIST_small/D\n",
      "Full dataset tensor: (1873, 28, 28)\n",
      "Mean: -0.0492167\n",
      "Standard deviation: 0.459759\n",
      "Pickling notMNIST_small/E.pickle.\n",
      "notMNIST_small/E\n",
      "Full dataset tensor: (1873, 28, 28)\n",
      "Mean: -0.0599148\n",
      "Standard deviation: 0.45735\n",
      "Pickling notMNIST_small/F.pickle.\n",
      "notMNIST_small/F\n",
      "Could not read: notMNIST_small/F/Q3Jvc3NvdmVyIEJvbGRPYmxpcXVlLnR0Zg==.png : cannot identify image file 'notMNIST_small/F/Q3Jvc3NvdmVyIEJvbGRPYmxpcXVlLnR0Zg==.png' - it's ok, skipping.\n",
      "Full dataset tensor: (1873, 28, 28)\n",
      "Mean: -0.118211\n",
      "Standard deviation: 0.452261\n",
      "Pickling notMNIST_small/G.pickle.\n",
      "notMNIST_small/G\n",
      "Full dataset tensor: (1872, 28, 28)\n",
      "Mean: -0.0925503\n",
      "Standard deviation: 0.449006\n",
      "Pickling notMNIST_small/H.pickle.\n",
      "notMNIST_small/H\n",
      "Full dataset tensor: (1872, 28, 28)\n",
      "Mean: -0.0586893\n",
      "Standard deviation: 0.458759\n",
      "Pickling notMNIST_small/I.pickle.\n",
      "notMNIST_small/I\n",
      "Full dataset tensor: (1872, 28, 28)\n",
      "Mean: 0.0526451\n",
      "Standard deviation: 0.471894\n",
      "Pickling notMNIST_small/J.pickle.\n",
      "notMNIST_small/J\n",
      "Full dataset tensor: (1872, 28, 28)\n",
      "Mean: -0.151689\n",
      "Standard deviation: 0.448014\n"
     ]
    }
   ],
   "source": [
    "image_size = 28  # Pixel width and height.\n",
    "pixel_depth = 255.0  # Number of levels per pixel.\n",
    "\n",
    "def load_letter(folder, min_num_images):\n",
    "    \"\"\"Load the data for a single letter label.\"\"\"\n",
    "    image_files = os.listdir(folder)\n",
    "    dataset = np.ndarray(shape=(len(image_files), image_size, image_size),\n",
    "                         dtype=np.float32)\n",
    "    print(folder)\n",
    "    for image_index, image in enumerate(image_files):\n",
    "        image_file = os.path.join(folder, image)\n",
    "        try:\n",
    "            image_data = (ndimage.imread(image_file).astype(float) - \n",
    "                    pixel_depth / 2) / pixel_depth\n",
    "            if image_data.shape != (image_size, image_size):\n",
    "                raise Exception('Unexpected image shape: %s' % str(image_data.shape))\n",
    "            dataset[image_index, :, :] = image_data\n",
    "        except IOError as e:\n",
    "            print('Could not read:', image_file, ':', e, '- it\\'s ok, skipping.')\n",
    "    \n",
    "    num_images = image_index + 1\n",
    "    dataset = dataset[0:num_images, :, :]\n",
    "    if num_images < min_num_images:\n",
    "        raise Exception('Many fewer images than expected: %d < %d' %\n",
    "                    (num_images, min_num_images))\n",
    "    \n",
    "    print('Full dataset tensor:', dataset.shape)\n",
    "    print('Mean:', np.mean(dataset))\n",
    "    print('Standard deviation:', np.std(dataset))\n",
    "    return dataset\n",
    "        \n",
    "def maybe_pickle(data_folders, min_num_images_per_class, force=False):\n",
    "    dataset_names = []\n",
    "    for folder in data_folders:\n",
    "        set_filename = folder + '.pickle'\n",
    "        dataset_names.append(set_filename)\n",
    "        if os.path.exists(set_filename) and not force:\n",
    "        # You may override by setting force=True.\n",
    "            print('%s already present - Skipping pickling.' % set_filename)\n",
    "        else:\n",
    "            print('Pickling %s.' % set_filename)\n",
    "            dataset = load_letter(folder, min_num_images_per_class)\n",
    "            try:\n",
    "                with open(set_filename, 'wb') as f:\n",
    "                    pickle.dump(dataset, f, pickle.HIGHEST_PROTOCOL)\n",
    "            except Exception as e:\n",
    "                print('Unable to save data to', set_filename, ':', e)\n",
    "  \n",
    "  return dataset_names\n",
    "\n",
    "train_datasets = maybe_pickle(train_folders, 45000)\n",
    "test_datasets = maybe_pickle(test_folders, 1800)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vUdbskYE2d87"
   },
   "source": [
    "---\n",
    "Problem 2\n",
    "---------\n",
    "\n",
    "Let's verify that the data still looks good. Displaying a sample of the labels and images from the ndarray. Hint: you can use matplotlib.pyplot.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "pickle_file = train_datasets[0]\n",
    "try:\n",
    "    with open(pickle_file, 'rb') as f:\n",
    "        letter_set = pickle.load(f)\n",
    "except Exception as e:\n",
    "    print('Unable to process data from', pickle_file, ':', e)\n",
    "    raise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# reference:\n",
    "# http://matplotlib.org/examples/ticks_and_spines/spines_demo_dropped.html\n",
    "\n",
    "def ndarray2image(image):\n",
    "    \"\"\"Show image from given ndarray.\n",
    "  \n",
    "    Args:\n",
    "        image(numpy.ndarray): 2-dimension matrix with color intensity\n",
    "                          in each cell.\n",
    "    \"\"\"\n",
    "    fig, ax = plt.subplots()\n",
    "\n",
    "    ax.imshow(image, cmap=plt.cm.gray, interpolation='nearest')\n",
    "    ax.set_title('dropped spines')\n",
    "\n",
    "    # Move left and bottom spines outward by 10 points\n",
    "    ax.spines['left'].set_position(('outward', 10))\n",
    "    ax.spines['bottom'].set_position(('outward', 10))\n",
    "    # Hide the right and top spines\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    # Only show ticks on the left and bottom spines\n",
    "    ax.yaxis.set_ticks_position('left')\n",
    "    ax.xaxis.set_ticks_position('bottom')\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQgAAAEUCAYAAADX4qgfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n5IAwsyQHhJkl/T/4DLlUBFKw3gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1115a0790>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQgAAAEUCAYAAADX4qgfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1119c8910>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ndarray2image(letter_set[0])\n",
    "ndarray2image(letter_set[10000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cYznx5jUwzoO"
   },
   "source": [
    "---\n",
    "Problem 3\n",
    "---------\n",
    "Another check: we expect the data to be balanced across classes. Verify that.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distribution of train dataset\n",
      "class: a, total: 52912(10.0% of all data)\n",
      "class: b, total: 52912(10.0% of all data)\n",
      "class: c, total: 52912(10.0% of all data)\n",
      "class: d, total: 52912(10.0% of all data)\n",
      "class: e, total: 52912(10.0% of all data)\n",
      "class: f, total: 52912(10.0% of all data)\n",
      "class: g, total: 52912(10.0% of all data)\n",
      "class: h, total: 52912(10.0% of all data)\n",
      "class: i, total: 52912(10.0% of all data)\n",
      "class: j, total: 52911(10.0% of all data)\n",
      "------------------------------\n",
      "Distribution of test dataset\n",
      "class: a, total: 1873(10.0% of all data)\n",
      "class: b, total: 1873(10.0% of all data)\n",
      "class: c, total: 1873(10.0% of all data)\n",
      "class: d, total: 1873(10.0% of all data)\n",
      "class: e, total: 1873(10.0% of all data)\n",
      "class: f, total: 1873(10.0% of all data)\n",
      "class: g, total: 1872(10.0% of all data)\n",
      "class: h, total: 1872(10.0% of all data)\n",
      "class: i, total: 1872(10.0% of all data)\n",
      "class: j, total: 1872(10.0% of all data)\n"
     ]
    }
   ],
   "source": [
    "# In other words, we need to see the distribution of classes in dataset.\n",
    "def check_distribution_from_pickles(pickle_files):\n",
    "    all_data = 0\n",
    "    infos = []\n",
    "    for label, pickle_file in enumerate(pickle_files):\n",
    "        try:\n",
    "            with open(pickle_file, 'rb') as f:\n",
    "                letter_set = pickle.load(f)\n",
    "                infos.append({\n",
    "                    'label': 'abcdefghij'[label],\n",
    "                    'total': letter_set.shape[0]\n",
    "                })\n",
    "            all_data += letter_set.shape[0]\n",
    "        except Exception as e:\n",
    "            print('Unable to process data from', pickle_file, ':', e)\n",
    "            raise\n",
    "  \n",
    "    for info in infos:\n",
    "        percentage = round(float(info['total']) / float(all_data) * 100, 2)\n",
    "        print(\"class: {}, total: {}({}% of all data)\".format(info['label'], info['total'], percentage))\n",
    "\n",
    "print(\"Distribution of train dataset\")\n",
    "check_distribution_from_pickles(train_datasets)\n",
    "print(\"------------------------------\")\n",
    "print(\"Distribution of test dataset\")\n",
    "check_distribution_from_pickles(test_datasets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LA7M7K22ynCt"
   },
   "source": [
    "Merge and prune the training data as needed. Depending on your computer setup, you might not be able to fit it all in memory, and you can tune `train_size` as needed. The labels will be stored into a separate array of integers 0 through 9.\n",
    "\n",
    "Also create a validation dataset for hyperparameter tuning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "collapsed": false,
    "executionInfo": {
     "elapsed": 411281,
     "status": "ok",
     "timestamp": 1444485897869,
     "user": {
      "color": "#1FA15D",
      "displayName": "Vincent Vanhoucke",
      "isAnonymous": false,
      "isMe": true,
      "permissionId": "05076109866853157986",
      "photoUrl": "//lh6.googleusercontent.com/-cCJa7dTDcgQ/AAAAAAAAAAI/AAAAAAAACgw/r2EZ_8oYer4/s50-c-k-no/photo.jpg",
      "sessionId": "2a0a5e044bb03b66",
      "userId": "102167687554210253930"
     },
     "user_tz": 420
    },
    "id": "s3mWgZLpyuzq",
    "outputId": "8af66da6-902d-4719-bedc-7c9fb7ae7948"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training: (200000, 28, 28) (200000,)\n",
      "Validation: (10000, 28, 28) (10000,)\n",
      "Testing: (10000, 28, 28) (10000,)\n"
     ]
    }
   ],
   "source": [
    "def make_arrays(nb_rows, img_size):\n",
    "    if nb_rows:\n",
    "        dataset = np.ndarray((nb_rows, img_size, img_size), dtype=np.float32)\n",
    "        labels = np.ndarray(nb_rows, dtype=np.int32)\n",
    "    else:\n",
    "        dataset, labels = None, None\n",
    "    return dataset, labels\n",
    "\n",
    "def merge_datasets(pickle_files, train_size, valid_size=0):\n",
    "    num_classes = len(pickle_files)\n",
    "    valid_dataset, valid_labels = make_arrays(valid_size, image_size)\n",
    "    train_dataset, train_labels = make_arrays(train_size, image_size)\n",
    "    vsize_per_class = valid_size // num_classes\n",
    "    tsize_per_class = train_size // num_classes\n",
    "    \n",
    "    start_v, start_t = 0, 0\n",
    "    end_v, end_t = vsize_per_class, tsize_per_class\n",
    "    end_l = vsize_per_class+tsize_per_class\n",
    "    for label, pickle_file in enumerate(pickle_files):       \n",
    "        try:\n",
    "            with open(pickle_file, 'rb') as f:\n",
    "                letter_set = pickle.load(f)\n",
    "                # let's shuffle the letters to have random validation and training set\n",
    "                np.random.shuffle(letter_set)\n",
    "                if valid_dataset is not None:\n",
    "                    valid_letter = letter_set[:vsize_per_class, :, :]\n",
    "                    valid_dataset[start_v:end_v, :, :] = valid_letter\n",
    "                    valid_labels[start_v:end_v] = label\n",
    "                    start_v += vsize_per_class\n",
    "                    end_v += vsize_per_class\n",
    "                    \n",
    "                train_letter = letter_set[vsize_per_class:end_l, :, :]\n",
    "                train_dataset[start_t:end_t, :, :] = train_letter\n",
    "                train_labels[start_t:end_t] = label\n",
    "                start_t += tsize_per_class\n",
    "                end_t += tsize_per_class\n",
    "        except Exception as e:\n",
    "            print('Unable to process data from', pickle_file, ':', e)\n",
    "            raise\n",
    "    \n",
    "    return valid_dataset, valid_labels, train_dataset, train_labels\n",
    "            \n",
    "            \n",
    "train_size = 200000\n",
    "valid_size = 10000\n",
    "test_size = 10000\n",
    "\n",
    "valid_dataset, valid_labels, train_dataset, train_labels = merge_datasets(\n",
    "  train_datasets, train_size, valid_size)\n",
    "_, _, test_dataset, test_labels = merge_datasets(test_datasets, test_size)\n",
    "\n",
    "print('Training:', train_dataset.shape, train_labels.shape)\n",
    "print('Validation:', valid_dataset.shape, valid_labels.shape)\n",
    "print('Testing:', test_dataset.shape, test_labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GPTCnjIcyuKN"
   },
   "source": [
    "Next, we'll randomize the data. It's important to have the labels well shuffled for the training and test distributions to match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "6WZ2l2tN2zOL"
   },
   "outputs": [],
   "source": [
    "def randomize(dataset, labels):\n",
    "    permutation = np.random.permutation(labels.shape[0])\n",
    "    shuffled_dataset = dataset[permutation,:,:]\n",
    "    shuffled_labels = labels[permutation]\n",
    "    return shuffled_dataset, shuffled_labels\n",
    "train_dataset, train_labels = randomize(train_dataset, train_labels)\n",
    "test_dataset, test_labels = randomize(test_dataset, test_labels)\n",
    "valid_dataset, valid_labels = randomize(valid_dataset, valid_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "puDUTe6t6USl"
   },
   "source": [
    "---\n",
    "Problem 4\n",
    "---------\n",
    "Convince yourself that the data is still good after shuffling!\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distribution of train dataset\n",
      "class: a, total: 20000(10.0% of all data)\n",
      "class: b, total: 20000(10.0% of all data)\n",
      "class: c, total: 20000(10.0% of all data)\n",
      "class: d, total: 20000(10.0% of all data)\n",
      "class: e, total: 20000(10.0% of all data)\n",
      "class: f, total: 20000(10.0% of all data)\n",
      "class: g, total: 20000(10.0% of all data)\n",
      "class: h, total: 20000(10.0% of all data)\n",
      "class: i, total: 20000(10.0% of all data)\n",
      "class: j, total: 20000(10.0% of all data)\n",
      "------------------------------\n",
      "Distribution of test dataset\n",
      "class: a, total: 1000(10.0% of all data)\n",
      "class: b, total: 1000(10.0% of all data)\n",
      "class: c, total: 1000(10.0% of all data)\n",
      "class: d, total: 1000(10.0% of all data)\n",
      "class: e, total: 1000(10.0% of all data)\n",
      "class: f, total: 1000(10.0% of all data)\n",
      "class: g, total: 1000(10.0% of all data)\n",
      "class: h, total: 1000(10.0% of all data)\n",
      "class: i, total: 1000(10.0% of all data)\n",
      "class: j, total: 1000(10.0% of all data)\n",
      "------------------------------\n",
      "Distribution of validation dataset\n",
      "class: a, total: 1000(10.0% of all data)\n",
      "class: b, total: 1000(10.0% of all data)\n",
      "class: c, total: 1000(10.0% of all data)\n",
      "class: d, total: 1000(10.0% of all data)\n",
      "class: e, total: 1000(10.0% of all data)\n",
      "class: f, total: 1000(10.0% of all data)\n",
      "class: g, total: 1000(10.0% of all data)\n",
      "class: h, total: 1000(10.0% of all data)\n",
      "class: i, total: 1000(10.0% of all data)\n",
      "class: j, total: 1000(10.0% of all data)\n"
     ]
    }
   ],
   "source": [
    "def check_distribution(labels):\n",
    "    infos = []\n",
    "    for index, label in enumerate('a b c d e f g h i j'.split()):\n",
    "        infos.append({\n",
    "            'label': label,\n",
    "            'total': labels[labels == index].shape[0]\n",
    "        })\n",
    "  \n",
    "    for info in infos:\n",
    "        percentage = round(float(info['total']) / float(labels.shape[0]) * 100, 2)\n",
    "        print(\"class: {}, total: {}({}% of all data)\".format(info['label'], info['total'], percentage))\n",
    "    \n",
    "print(\"Distribution of train dataset\")\n",
    "check_distribution(train_labels)\n",
    "print(\"------------------------------\")\n",
    "print(\"Distribution of test dataset\")\n",
    "check_distribution(test_labels)\n",
    "print(\"------------------------------\")\n",
    "print(\"Distribution of validation dataset\")\n",
    "check_distribution(valid_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tIQJaJuwg5Hw"
   },
   "source": [
    "Finally, let's save the data for later reuse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "QiR_rETzem6C"
   },
   "outputs": [],
   "source": [
    "pickle_file = 'notMNIST.pickle'\n",
    "\n",
    "try:\n",
    "    f = open(pickle_file, 'wb')\n",
    "    save = {\n",
    "        'train_dataset': train_dataset,\n",
    "        'train_labels': train_labels,\n",
    "        'valid_dataset': valid_dataset,\n",
    "        'valid_labels': valid_labels,\n",
    "        'test_dataset': test_dataset,\n",
    "        'test_labels': test_labels,\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "collapsed": false,
    "executionInfo": {
     "elapsed": 413065,
     "status": "ok",
     "timestamp": 1444485899688,
     "user": {
      "color": "#1FA15D",
      "displayName": "Vincent Vanhoucke",
      "isAnonymous": false,
      "isMe": true,
      "permissionId": "05076109866853157986",
      "photoUrl": "//lh6.googleusercontent.com/-cCJa7dTDcgQ/AAAAAAAAAAI/AAAAAAAACgw/r2EZ_8oYer4/s50-c-k-no/photo.jpg",
      "sessionId": "2a0a5e044bb03b66",
      "userId": "102167687554210253930"
     },
     "user_tz": 420
    },
    "id": "hQbLjrW_iT39",
    "outputId": "b440efc6-5ee1-4cbc-d02d-93db44ebd956"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compressed pickle size: 690800441\n"
     ]
    }
   ],
   "source": [
    "statinfo = os.stat(pickle_file)\n",
    "print('Compressed pickle size:', statinfo.st_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gE_cRAQB33lk"
   },
   "source": [
    "---\n",
    "Problem 5\n",
    "---------\n",
    "\n",
    "By construction, this dataset might contain a lot of overlapping samples, including training data that's also contained in the validation and test set! Overlap between training and test can skew the results if you expect to use your model in an environment where there is never an overlap, but are actually ok if you expect to see training samples recur when you use it.\n",
    "Measure how much overlap there is between training, validation and test samples.\n",
    "\n",
    "Optional questions:\n",
    "- What about near duplicates between datasets? (images that are almost identical)\n",
    "- Create a sanitized validation and test set, and compare your accuracy on those in subsequent assignments.\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def intercect3DArray(A,B):\n",
    "    \"\"\"Function to intersect two 3d matrices.\n",
    "    Args:\n",
    "        A(numpy.array): 3 dimensional numpy array.\n",
    "        B(numpy.array): 3 dimensional numpy array.\n",
    "    Returns:\n",
    "        numpy.array: 3 dimensional numpy array.\n",
    "    \"\"\"\n",
    "    # Flatten\n",
    "    A_flat = np.array([x.ravel() for x in A])\n",
    "    B_flat = np.array([x.ravel() for x in B])\n",
    "    \n",
    "    nrows, ncols = A_flat.shape\n",
    "    dtype = {'names': ['f{}'.format(i) for i in range(ncols)], \n",
    "             'formats': ncols * [A_flat.dtype]}\n",
    "    \n",
    "    C_flat = np.intersect1d(A_flat.view(dtype), B_flat.view(dtype))\n",
    "    \n",
    "    _, nrows, ncols = A.shape\n",
    "    C = np.array([np.array([x for x in y]).reshape(nrows, ncols) for y in C_flat])\n",
    "    return C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of intersects between train and test datasets: 1153\n"
     ]
    }
   ],
   "source": [
    "intersects = intercect3DArray(train_dataset, test_dataset)\n",
    "print(\"Number of intersects between train and test datasets: %i\" % intersects.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L8oww1s4JMQx"
   },
   "source": [
    "---\n",
    "Problem 6\n",
    "---------\n",
    "\n",
    "Let's get an idea of what an off-the-shelf classifier can give you on this data. It's always good to check that there is something to learn, and that it's a problem that is not so trivial that a canned solution solves it.\n",
    "\n",
    "Train a simple model on this data using 50, 100, 1000 and 5000 training samples. Hint: you can use the LogisticRegression model from sklearn.linear_model.\n",
    "\n",
    "Optional question: train an off-the-shelf model on all the data!\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "default_view": {},
   "name": "1_notmnist.ipynb",
   "provenance": [],
   "version": "0.3.2",
   "views": {}
  },
  "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
}