From 1924ab03957f48ded78c1fcc380febb719023315 Mon Sep 17 00:00:00 2001 From: Jonah Joselow Date: Wed, 29 Jun 2016 17:34:07 -0400 Subject: [PATCH] init --- 1_notmnist.ipynb | 1551 ++++++++++++++++++++++++++++++++++++++++ 2_fullyconnected.ipynb | 777 ++++++++++++++++++++ 3_regularization.ipynb | 1138 +++++++++++++++++++++++++++++ 3 files changed, 3466 insertions(+) create mode 100644 1_notmnist.ipynb create mode 100644 2_fullyconnected.ipynb create mode 100644 3_regularization.ipynb diff --git a/1_notmnist.ipynb b/1_notmnist.ipynb new file mode 100644 index 0000000..9b4c633 --- /dev/null +++ b/1_notmnist.ipynb @@ -0,0 +1,1551 @@ +{ + "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", + "code_folding": [], + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "collapsed": false, + "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", + "%matplotlib inline\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" + ] + }, + { + "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": [ + "Found and verified notMNIST_large.tar.gz\n", + "Found and verified notMNIST_small.tar.gz\n" + ] + } + ], + "source": [ + "url = 'http://yaroslavvb.com/upload/notMNIST/'\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", + " filename, _ = urlretrieve(url + filename, filename)\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": 4, + "metadata": { + "cellView": "both", + "code_folding": [], + "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": [ + "notMNIST_large already present - Skipping extraction of notMNIST_large.tar.gz.\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", + "notMNIST_small already present - Skipping extraction of notMNIST_small.tar.gz.\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": 46, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACRUlEQVR4nG2STUiUYRDH//O8z368\nvvu9qGyZH7upaaYb9GEYlVFRknTJsFsWHTt1rEvnunSIQKhDF6EuBR6MwkzE0CQJKiFF11owd9Vd\nM0133/eZDtruYs1pmP/8/swwA+TCZRB0GyhfKUi9zpbwSNn7KWJsD4Ezj4d4+tvtCvEfreH+GGcs\njt/Nu+XbxO9qlmB/Sd0/qA0XlVLMnJ6/k5tkq0tkz3fNKwLYa2gV22wJh9itWRYYc5fLcsiW6HLW\nGUzmIni35yC4UCQzsj+saO3N+DipYNVplV+f4K58Ns4WD/uv9/1kjt2r3YQ2yeLETNQkNbA8s6wB\npd7yvC1rqQtXVyRNJAID/SMxOE85vIpypLzkM3hpcHhBvf5RzDBaG3IkWc3NmkBqJQ271S9ZFe+I\nh7S/trvML0BqcvirWF9K9whYnS1rNgASIOG5doRJD54ITB2eMU4u+bTMlbFpABLE/r1NToKokY3R\nwY6AYSfQgcjiIjGgaU3dSVaKmVmtWhvMzCY/DUtAgOjY2Q0wccYC67BDKQD1uhMQZLoDJT4I0yRO\nILH6fZ0FC+j1RSDJjrZmMjj7cK79ecyfOqr37uuotVxVNz4kCLL+5ifO8pNzERR54LOHg/Zbr2bZ\n+tgDErqjuoZlKrYQx/qKXM5OpzIPRn0QO5NdmnA3ttpUenB2coMUm8zEWvrlrwX2tFWawt8ZRppG\ne9XWhZkVJoYcq7aIuUfi7bvS4y8eJQu/zdeth/qin+OQoUqbSycqFPWgLDec7e4/wqfzL3yRo74A\nAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAmUlEQVR4nNWSuxHCMBBE390ock4B\nhBRBkU7cEEUQUgAd2JpbAhOcxNhmyFC6s9+Tie3nO9g+WACI6DkOYHueBQi/3zxzPa6XcEDSorHn\njFokrZ5DKTXL1SEHqmSQGgk099zJ3RJYY87E+a1jAtnz0VQynU+yL3qCPhYyONj2UHYz0Drf1HOm\nNF/xbr7SpG0uGrGa/P5N/gt8AZ3pRmUkGBjdAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABvUlEQVR4nF2SvWvTURSG33tvagQd\nJJHioHTQLAFTEBUUN/0DimAN9WNpHcWhi9DJUa2uOrkIkjGTVTSgk+LgIlKF4lBFsWgQRaz9nXse\nhxjy8a7PPe97z0dQX7tq1Upj+te9R9E1oqhae30LwLmlMA5PbOJky1ZwQ2mUBlVP3ywA3JgZpzHq\nNhkgs7pjzDlpEQOAgssqjYYe+IH3YGZ1+0hp1H0K8CIDmeZwatRx7zXiDsaK4jB8gOH8bL3Dcf7W\nBzSqvomTOat9X3CMpYFv0jIFmWcq6w4FmRfqfylo92eczDmVtYDheKPvm3QFw+gEJR10oGDxf6tB\n5bdkMk1tiyWtYBhPFaQoRZ2pexSqyh29khR1ZIqeb3hJBmd9rlE/em0DB+OCkqSkmd7Eh2W0lCQF\ndTDArPfEDHA+VRSUdBIHz0D349paF7JDZlZJUW0M8OeXDk/uTKXJU20yGA8VpEOOO79nByNZyI5j\n05LuYhRc1UQphhBCSBNaosBYlvZ3cedPbbCGEPUEcz5UdJ3cDxgsqfYdcy7qK/gW8yMHl9TECx7r\nPZ55PXZvSee/QUfH3thGa2r8ypP2zM3v/Qc/XFyTTEFB/AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACsUlEQVR4nDWSS0hUYRzFz/+734wz\nd5xxRp2aGZOUnmomRYZhghhFJFGrogcVREQgtGzbPoMiaRURRYs2QZYEulB7IFppSYW9rIYejjM6\ncUdveu/9vn8L7Wx/nLM45wAUCAHxAMqLAECQQfgvSYZ5cNuI7d8U6vu5zsz3VPxeIPASJDRGL9Vm\nsytiXsAaXKzKfnv1cM6hJUr1B2e7FAnt+RkEAPPDd15+dJfMZumYzUppVjz3V7PrKW2Pb1uKFbae\nCGohSAtPBBYswxAs61vXlksAEgfkfIjJKbzNPVjZVlRdzWLRt6/mQTcACf5pkenZhWNqxr3d2jF0\nFEFU//CDGCL0NgYTFB1dM6190886G8GwKDdhMCBWZSIJBiH4KxlQxcnNDOiIO2IoAsSHhesFYsL2\nQ3UNxsaG9vWaxIwzlwswIEuOZwyAED6UmuzYKKtA2pvvGiwQAJnKtksQwBsamADA87qf9hT+Fzzg\naWZmT7F2NSvX+n21ORYAAImtn5oJABvKEsVps5zCwTORqbuzv4glWsP5UgOefD4sijeULXoJR/pO\n/pkbqHhBQPvFtMOK+49sSbTUrt59fmpcsdZ8IVoJrK3t/8Fa8f0avyADWNP5Js9auXYTSEx/f5wC\nCPFEMgot5Bcr6SkS6nMLTGBnW441a3VahImIhHzJihX3bk2cEvV76ksBRX23UoWIaUTpZHxKsNC7\nd8yOy8lrPXYIhq4493VvNrNqXfxszgTTkwz7XgOhm6yZlcP5Ozfej+aV4yp2eOxyggRw4l6BlWKt\n5+0sa/Y0e3m2uusgIEGOzWFmkAn/36AiPTPedOXFm3dCQ9JQfFfYykSi7Eh/MOslrde9E11pJTRA\nRf7WysOjM2FfumRFunFzZxU9+oJZd/nWKI4itL8MsVQyhHAJ4DOxPNg/HwVPlq8jcpoAAAAASUVO\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAwklEQVR4nKVSMQ4CMQxzIrOw8wC+\nxsB/WNh4DY9gRMwwM9CoZiiq2uruQMJjLDuuG2gCSXsQgGMBiyQBADl3w4CRlXQfFCkCgAnIfjl7\nr709AACSkg7jtpMkqdiuyWhtI0WwBgq0JMKISpp3kdyteUrkVyt8fXxMgOx+NTWkabuRFXIWxVZ5\nGJeli91+tZ0NVOo7jpqjUq2PPtTHLm33ozmrIZ3sgyiiks/oe8eKxA+fPYFds3M8MK7ImDkwUIH4\n56jfadaL1+aSITQAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACG0lEQVR4nFWST2jPcRzGX58/v/3W\nz2xaWxYNMTLhrOE07YJEm10c5eogSuYml90sKaXk5KCUlBNDzYFsaRd/pkbRMlZm5rff9/N5Pw7f\nOXiuz/v9fp7n3ePoPrW5VmttW9e2ttmW/yzOfph8PIvHAE5+kul/LD4ZDHiAcTVSSjmbKaVUFDll\nmV714oF9jX+bWZKUTJYKLfThgadKkiTTw6P9Z1+XM4Xed+JgpCSTbuIcjJRnGrpChH5lSaYfXVRC\njIwqScp62wRs/SWTsqZwQGDbkkwy1XvxfJlHADUnwPiygMBZtQPvVuYBHB1deO8j3e04ECzhHXPl\nZPt+nJkxuCY7cvY3pjyB26sOpntaNu06MfazzH3V4whcV1Hm/P3tV1Lp5tkBvIPAaEkqm5RW6kky\nHaLqwDsalHAGoakazMTYppUAEYqSE+Hjm9+Vtp7tYDvHhyZDJnJZhSTT8pkIEPpnZUlLxwlELq2S\nw4QQow8MyJRNRyByUYWUdJ+KA3C+aVpZSe9bPVRKzXtIpXZjERFs+zEv1gIKebKsDd627MWD6PNQ\nA6CxUP6fwJmW7ABqHhKSo3kjIcYQY3H4Qtku5oicVyFlvdyBA8fwkkyS5XzQedvzYH2zA+oT05/f\nbRgaEA6ZVW6dBqh195xTTqslTKls550qEdxyI1VRwATOBYDl59ceeecAb7vvdqpaCdH7VK9//zoz\n8WIGL/0FcVWAASyACC8AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACW0lEQVR4nG1TTUhUYRQ993t/DjMv\nx9GZ0skMNXCMhjTMH5LANkGtskURWQQFhYsWtYtatGnXyk1UUKsWLcQgKs0oxCyk0EKirHQGmdJQ\nZ7SZ5r33fbfFqAl5VhcO53Du4V6gAAGDjCYbW0Ja1ILQAABU4IgDdXZDtjY63jGwHHw/sqTIWyGJ\njd3t7dtrpc9UnjkRErfePFcuc0FXWtX7kXMuK1eqPLs8P3P+4IpnsLblmetIz1ueYzeppFIeZ+6c\nBOkQqix+5oBQrE2RnZrzDTdAN127VbkPdCAUOX5IsnD6rZdvv/4uKY9HurytMvbnZiksf+tjpaT6\ndr2lEgQTlYFN+7rG5scvhiO6S3vbCFn0DC6mSLBDScLwmD88OpQhkD3CipeGaiAK+YgE7PLYTo1I\n56PVAJyHWaCwF4OxnE0BgLBTCdCngd4UFNbAkgQAYcaDgC3mV4tcpRUAUceAE/2S0Rn/QXzORGBO\nZoIebUCKrinAXCg2N1Jagz5g89kKZ71yZRa/7qbhWSK+PhCxKCIAIptOQmBbdaPS19w4ZLWVQQAC\nh5Ms+ft9P4iICCAqLjt2oxMCIHS/kCw521cDTQOEYUaaLizyeHNFMaCh+12aOZftv3rqiBWKGeee\nPsmzUrOdJQTiYGePNAwGMvd+NE7uioUCGvLTucsDAOATl37O5tjjjMtScTrPkhO3TxdFCAA0f0f4\nyp9qneERlAG5MPHh0SuXC6dpONFrc817OGA4bE3y9EzfaIJ4rQtVr8JVDfrEicRw/eshTAvGvz4J\nIAFrx/4qVAlQ4R3+AvRIAkjLR9cFAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAWUlEQVR4nO2SMQ6AUAhD+0knb++Z\nPIQ3cZFQJzfAhFnWF1JauoR6rGE9JAAgIoWr0ySAsPOwdFfSrb3T3EivD3JkcO7zh3izNbKGl2e5\nY6l59mdNZgWb+3wAAy8c6wBZM9UAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAB7klEQVR4nG2ST2jPYRzHX8/zfLfG\nxtJCLTeNORiWkVqZy5KDA6VW5MKiVju5OiiOpuSkdlBuHIRkhRXlTzhoQpM/C6mxpqz5/Z7n87wd\nvr/9k/ft6dX73fvz+TwOAE9mQ8+WjtbGpoafj4fvRO+zEAABf+jujOb1ZL9nToH2+8qyVIlmMSaT\nnp9sW7u6ZLunFaMslz6zZNIfuwV4Nk0qSlmVKwd37hl4JMtKyfS2EYd/qCiZJnbhwNE3JZOyUieB\ngdI3vZW6IoQisH1SJpkGoOWzspQ0SH3Zr56eWZmiLsNgGfphBa7Wvo4jStWos9S9lElRpwnzsxWc\nUrahBnqVpSzrYmFwPPvObcMxrCSZxov51JJCcHwv69xcbARCEcB/RCAmlhjBkoG/UT5+/wPL8BHz\nIOJ/4dhrMo6VtestyIGvvkA42rClhZyC94wCns4WLcr13pyzDOtnlJV0jGIR4/CzseFWHKNKMo03\nz9PA8qvKSRcp6FeSkq4VhCKEEArWPVWMlo7iaP4kk5IetOMAT/cXxZztABDoV9Uk0+z143u7u3ac\nj0qq6hIF4LkgSzFVax9MZrmqd2vKtXhO/FCWcqWSzFI1WtabjXOX8KzqG7r9PtWcWd/ONOEprc4b\nsKyjt3dz0+yvr6/ujUx5MvwFJjdHTEBpw1gAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACmUlEQVR4nD2RS2tTURSF1z7n3Juk\neZortlprlVaw0oEKKgVfrYhUcCAKDoQ6ERw48g+IA0HszIkgiODEiaIURfCB+MLWJ4qPVo22VNFo\n+jBpGpN779nbgYlr+rFg728BiEaRSiGbJiACECk0QnDaBmwu7CnebekaGd74vEwBKduAG7oGIzlv\nYWz+/YwXSY1UJ4Y+UpUYAChzKn4gNGwNQQgInnU8e/hmZJYEAOJ9ebE2ZAnKVqwVEf/X5SN9AAAT\n/tYgEvGDuF9Mh2GanWxn952XFZ/E4FA57WD818sfU0ujY3u91sWsV8jqg9e+AKb2rtcR+VQ56kNt\nn7420JdIcVJ6RzdNuhW0brldkbnC6Sw5CiBsG/gplsWeyHow2gtiHEt8maEAWsS5b/p3mSarO4oA\n0HNSWGoXsqD6422nLom1U+sBhd2KSdz2SF2ZEBfjIOsd86IqNbdFScCPfmip48r95UVy5tzjVVW6\nuQ7ilirghu7ZRbkqJD4+lFLNOwtM8Meyzv8xxoNmger+s0b9bGcWPN6Z9P/DSBsgtdzmRypyOW9U\nOaNm6tfCRJvnAXa8t6xaFwGIbnPdek0F3fvXAqb2uQw1NTEJqzA2rUAAaUlnDAH4PTgcU6XuUatV\nbc8qJpCCmM59uzXT8JUDtT9mwRqtJYw8HUOTW1LJra8HDrNiUPkBlKldvQg4frZ/WaFilmS6BjuY\nrM6/uPWEGO72orCEZcmd//qtUJ6tCdtAHvQnACB+9rMvliWcKzFzKBJa+XCuXSsAZn50q2YlohNc\njTLJbHr+1dCV72QBmJZ7O1bShLOQg6bYtM7k3ySv3/he+GeaYhujK3c9TOp8C1q7zvS+el94odk2\nFnJB6OlE85I4UgkkPChqSP4LWLY5ylFX9YgAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAiUlEQVR4nO2SOw7CQAxEX1aThmNS\n5D4cgNNwCGp6apodZSiQVtkoREhpmdJP/oxtsqGaCQGFHe1CATDPXdAMUoOlrDKqDQyBudxvpc99\nPAFIUnNZd7smST5lT5KXZV1ttYHMEuJB6IjPP6TdU+qDsRt8ud87o8QPx97QedFz/WAaJX95MBTj\nIz7fvX5hxWql5uMAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAB/ElEQVR4nFWSv0uVYRTHP+d57yv9\nuIsJYUFIQoFDgTQYSRJFi1sgCE219y8EDdUStDSVNBo2uDjkUEhLEoVYWZAVRVhkebMir9573+c5\n34b3anWWwzkfvudwflhw9hwb7O/d3dFqNmvflp7OzW9YcAEQzkyv6l/z11d7yAyACbk8JpfkMcYY\n5fp9gWAAn1R4KUkuKSalIukmZsDplkroarz73JCS5C3dIAMYV5SkpGd9ler+8y8UJRU6Rwbsq8kl\nuU6QYVTGFKWk5W6MwIMyeruNYCEPTClKha6RYTwsg4myS8ahDblctb0EUcUAFkuXsoUpHEtdIwTy\nKoCxSLkVuIuBMQLsWFKSXANlWYyuFblc632Byk4M2drXtlLh+2Mc8+3HA3kOiOVNSOARgDgSyA0Q\nqxuhDZ0ZAkAW8DJVZ9PEqw/mGF8CrQjA2l9o9Z8AvA80fyGgXo4JBPUewBTWZgMbH9F/SuNkNZmY\nXwwV5hBifQs6o4C4DYH+pjzqVnsHVDgqedLzHMi4oiJqhjyYhawC9xWVNEwGGYOSq9FPAIx8TEkt\nXSYDjM6a3PVmpGdX98FTFxeVvKVJMwMMnijJXfXaj4akooia7GhPljGuQmpFSYrNJBWXghlQAWMB\ng9xn78WzhwPL09dfZtq6wkCMWrkzZEZ1eHSok82H/wO8blL/DN0nigAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACvklEQVR4nCXBS2hcVRwH4N//3HPn\ndmZy59WZxnRotE3SRiNNkBRqEFF8gYuSLqUFBVFw4bpL3UhBdBF0J4i6EMSFm1JxodgQqWDG1KaF\nmjhN2jw7kziPZObOnXvP+bnw+wBxUwr6qINiLgOB+MARH4ACtDjuMy/E9VpyxpnfGB327rrnK83N\nqcLaz3FbMKHef6u95RxLJ00zzKfatVM7rWjs9rUv/SqKH8/eZkya0FpL2zeMDQ2vfnHZA1KJz8OA\nxljG7HYMrbVkwL27k0jorr8aJaEAOpHyuJaJM4emFCx+KgPQeOX8xjgFgfyo/6yr+ulrF0Z2wl+f\nPIx6VvD61OxYDlbtzDa2Ozh6Zr09pipJhBaAO/TJYkhaXn/H1S7+pwQiApXfq00KAJxePeJH5fE8\n0o7WKueQEAwNzj1vHEr7erVxY7p4v/Le1l9+9l7rQWpP49JqE4Ag81p2691kUPD6CXH0B7Jwi7q8\nkj5LBwByLIsAAPqxeyGz9hvh4MOwR5I01liSNIYk5wa1r83I7s7jFJAq6h6U/umkxzcbw+vNWy8t\nrWtMPlUvazBKfH/vYYUvDy2PDpvKUvDvnapoVE9OBD6RWF76oebu/627RhX8g326oC48GjmhIMTB\nnaoKxVAcu9cAVASoTu27QpoAzPHhxyAUGoi1sAKocCb4BRbA9PR2U1tFpUEQQkB5F8+MQWCxMDfU\n8oo2qWLfoyIEkHT36pV+AojWf7p5fHXgvpcZuOEXd9ncFwiylz7KCoBQub8vvhFtZr3DVg43v+pt\nNAVvnzv7rBUIEUgvR2XpYOlk/Fnnm4bCyn5qDQJAUsn8IQgQU7m43GtZLSuFmUnstgtZE4nrR80S\nzENTSmx96/bFl9GJ50bmmcWDfEbh1e2v36wvZ+zCH0/PE4BTUnjiokbuxLFBuL4HnHsR4rjAfx8L\nVmj4yxNsAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAfUlEQVR4nJ2SMRaAMAhDA4/J27t4\nIQ/h6AHcHbSPOHQF6mvX/5qEgBD504LV0AAA7iGUytMAuB67hn9Jvlwrz8Ws5YEaciiq0UwdNn8i\nTyFAuc5wpOGcAOOGym6HsmmgXt9WBTIt6qOHG+1QzXLZu0WqEBbL/lHfzIHNH/UHunM3B1DxS3wA\nAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAB9UlEQVR4nG2SS0tVURiGn3U5Hs85\nbjM40kVSLMzQ6GKR0KyRNYlGQYMgIpr0Dxr5E4SGEdWsRs0aFUFQA8ECJ2mQgwgtkwrNc3Hvtd4G\ne5+DUd9wfbf3e9ZrjMYvnR3sK5cr5XK5xzkbQruxufF58dV8gNkdRf0bUU9K5th8EsCAQREw5CHf\nOA+3OrVZ/Ltza8LY+OBmcIBMa2GlUan2JbVKrdLbU3o5g+eGUklRTw93ZpaS+sGRsRp4rimTgl4b\nrHPOOVtsNfhCgninUtp9xkDEQxkBnCKjoxRjAmAhQWCZHJbr3OEIAFbUMWBCfQojY5333oaBiz0A\nlvvKJAUtXBlyxcoLS1ujWLw4RF50+tn26trP363A5LRfWcuVLClIktK0i6etR1iAwR85+CApa7ea\nrVa7peaJPHkuy5Px29dml+sdLOAZc8FBcI9v9+2tD4+ODO1PVuee2wjArFIpqlEMopAH4DmOAZnl\nRSuLBUVZE/Jk6SQGxDJI5MNi0e+P7MvJf8dZ5bflfAVcV5QUtNT9zQ5fg58iOrAaf//i7cr6ZjNI\nCPRry4o3BZ+YOyhmWZru7LSba/f6Ybtjq5imYZfFMj3ELB8NGGMASbtWxtLmGaY//NfTknTVULs8\nM3FgoNc2Nr58+rjufKVaTfb09ye14bt/AIEsWs7AbCgoAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACg0lEQVR4nFXQPUxTcRQF8HPv+2hp\nKaVICykRUwFBIwIqLISBzY9EMZFdE42Li5OrqwsTk4MxLkRFkzpoOhETExAwAiKBAJZvaBukD1pK\n+977XwdjlLP+coZzABhhgr8m6AcAvxfw1DL8tVUBgNDatNzWJcszaCknen+r9quxGOqoXh7dSXkI\njY+0m0bAzHtzHJAlT/1GMXOySjNmMw9WdNjF9ZBjwIcgbG6CE+UGVdSoke+P8vnOhOkpAwBRhqaE\nGUW3jFRZeqkBiKwufBBXRFzZydrOftpyZD9T2tp72EyxaEfk9lkhCE0M9Exn+1IlvznevTq/OCOE\n9p3hbtsAjqZHJjbdxVCL+uSYpgWQ6Cj/daiyYRHvXPxC3CVrBUSFou6yApuRe6LCIHbvXp86AYDY\no6pCokFIp9YbqhAAQNudud6n1DOZcarL1lr2CmsuoXwo2uHqAKzNQotHK6WCjvbD7lwbGpmjyJny\nhkHFAAAoAsh22QQwltB0rfJaDAQAIsyAiGEAJXN1wR1na/bqzxekAAhvfl7L03qykN4wsB6dTFK0\nKd3/hAAoN/8xm+ZmIxf6Vnlx7E0uyfpWbK8PVlCIX6dyL+0kKus89sqBafuUreMgWCQGKT73rDpl\nkWSzZJTIRh7EuDTgZgICLsQuxzVNQEwlEghBmL8f1YUVAfS2ptRfDxKlSCAQgNXy6vNDAuC5k4Yv\nDwEgf1ZDr2hPxHyKACvV1htP018AAH1/Z9ge71J8YM4vyjb+N+ixiqlsK4AAzNCXAo6F1/H4dI+C\ni3y9Ef3z4z90Tu3q+Qyz+BODV3Q5prq2Yr6ztAOLrFdzXm/uWJMQkUNfMRgueZO7pqOO4W+O0iiw\nuNK6JQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAb0lEQVR4nNWSuxGAQAhEF4bI7k1s\nyCIMLcAOlGENLgVuxkzSN9x+OCHq0Yb10AAAESmUTtMAhB67prskH66d5mLmtSFHDUU1yzSgx51p\nCgHKdaaRpjkB5g213U6fLQ2N+rbOkGlTHyO96Pdv8i/4AqpUK3nRGD14AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAByElEQVR4nG2QO2tUURSFv33uuY46\nM3cGjY/oFBozUVsfCGJlYy/YRCt/QBoR7Kzs0liKkFqwEAQbCQaSwhcYbASjRCXBB45gzBSOc89Z\nFvdOQsis8qy99vrONgAw7b54abyWNWrV1Prrvz6/ePTWifP3r7Zr2dk7H7RV+b0KfJT6K98kxTyE\nEKMkxZjnuaax7k4SUHAORZUlZpCnUywoKARJimHL2p7m/NMLwhXz/dn5H9Sre1ujBw9kiRFt4nUm\nA2S/L8+5WOxNmq3WiWwGHiiXpL5ukfpCVozgeFJCsITyQjJziffOs9iryEAcx1mJSxIDAOkXBUlR\nPydw3jvnnGdDb1T8RKvXdpQNeyaPUhQ/K4gUg5buTp4bOzR2c0WzGHhTl8HxQ7sN+d9KGskAPGw2\nOEBWI0T3GBfwYldpRRd7PasnBOBd2fmqAMr1/NTovpHTt5cV1DlS3vS9gqSghQwDo3r9ZfdG6fmv\nClLU+klSM3PeSBvlUpodRSnXNElJ7a3MweE1RUX9O7PxwiAH411FBS2yXY7UAWJ+sHWL2awA4tPQ\n5DGXI7E6xPTUwXA0h5gw8vD72p+ulhubjJvJzpVmFab2b+fhPyn8AavhoJQKAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAClUlEQVR4nE2SS0hUcRTGv/+5f3Pu\nzNzxkUmNNTa+eqK9C4uQKHsaUhS16EGrNkGrapuRi6IWLVoFQVBtWlT0gsJN5MJHZkkqpZZhKGmZ\n49yZ6733nBbXos2Bc77DB9/HDwAAKEI0VLs6nF9tzA+BlAquwRRVU7Sjqrf+Q/JbZ17f61GBzIoK\nuujUAaPMAuDpH9zzqLNV+xJ4Qlfs7hf2mdlllyUz/KJxLSgwLj7Z9J59z3eGU/LDEY996TqTAKAh\nennyREKEfrflo6XEXlEocFctMrUHDWPxmoaFzLrtfurtRJb2LI/tDed3JLVHrLAg/qyY1fitJ12u\nBy3RkqlddYV9HU/SLED5Zd+TsQ/JKBERoGCYZ5uXBhlV411x5fsm0GxkIgWLCAC0WV4PnR2YBCSo\nQ6BoOlh0JK6Zem7MzGpQCsJBfULWQL4g/GtQCQAlebkMxC2OhRWgzZPT0dQnG0oAFaqs8OZGjZxX\nc610r/VRU3tpNDLSneMCShJ3womRsfXvqnekzfbrCrEmcWVoPgEgbPTFt9mxhVne1hZTxhs3vNhR\nVoAg7yZgYk7IE4ajs9pt95VRkLSyLpQMxnvjny0nUgbG6OcpoOChMKe2aSLArDtYeXp7/eO0yNCl\nlQD0oSHx5cYWEJGGVnNQ+zwlPLNZaSjszDL7TtvxGECkKFLzfFIcuZ0IAwrRCylb3OHRq4ePlKC8\ntPnLuM/SvSJPA1AovDhtZ0Qmfr48eO3K0/4JcWXoFIwAISv3fDojbtaxPWGZTItM7y8lABpASj0o\nWLJvJiw5/oxCTLyW+18z/A/NCNadG2sIkcmO+dV+33ovk/4PajKqC+PlG/qq7Dfz2lrwW+EvtsFL\nUY5hLTu2FWW5NAsF/gAZnC28aXXH2QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAArElEQVR4nJ2SsQ4CMQxD3VwmmPkA\nRpCYmPlIFiQmPoaZmS/hGK4XM1DgWpoKkbFPcSzXgfBHGqwNFQBgVoWhdVMBmFzPUt0lOXDfujlT\njb6hCB8mc6EBWTr/QLHT2sSBwHbTkL2NY+fCyUgo4bzLFzN4uSdDgcsFA1J8x1L+wIFkNQSN+iX7\nDsGMEyiayWoqyPOxj1nuEX0yVvlssd3K5IeaVAom8pJ15/9SPwA8KT+o1oe2UgAAAABJRU5ErkJg\ngg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACA0lEQVR4nE2SPUiVURjHf+ec9y4a\nKUhYoWIfBNWUSBIREchdCqfmguamhsDBNXEwaiqkqSRE0sGGInDRIEIIi2hpqQi1IpWuld73Oeff\n8L732rMcznnO+X89xwFASOLguf7TXXvaKjsbK28mF52KDs6TXXz8U0nNuu9xAHhPdUlJtr0TUzSl\naLlGCACBzhkly/PyYZRkehdwEOj/LDOZfk1eOXOy+lwmJa204PAMbCiXomZ6CpoJ1ZNpyeGg85NM\nMo3hQhZ85plSNI2QAQ+US6ZHhFBId5XxdZtrxUHfH0lJq534hjFHR29xcbwAHSajUS6AdwCvFZW0\n3l16Bpz3WSh260oyze6ChnLNAtleHGIBn4pDxdb9LbH2Y9vw/JaUVKWUSsu9tb8x3/oyf6sP1pSS\n7EQJ6+nZbOZ/l2XFpO3uBqfncooxpWi5av4DAiXK8SX/5Jp3zvngeMYNxSQNNNWSMSqTlDTEsZpS\n/n8Gjn0rSop63wpzsqiP7bshBGZkMo0CFxRlukPFNZu3ZZL6IfBQdUVdJytpK0zJTC9wONqWVU9R\nN3EhhBAqdH1XNF0igOfQW1lumj2CA0fHvGJdTwsRnvZpKe5oa+rq+YGhsVXFXN+ONjLzDL605pdN\n9ai1s7tj8rjjwws1SSlJstleAjTcBSU4XB08dcBvfl2cfuV8BP4BIgpWc1z15nMAAAAASUVORK5C\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACsUlEQVR4nDWTS0wTYRzE5//tty0t\n2xawhVYQRSFYUUSNMQE1vlAPGBNM8GDUowfvXrx6M/GkJupJE40nT15EgvGFCj4IhABB5BVKWxFh\nl5budvf7ewDnOpnL/GZAgiDDABE25I+HAQSJIFmvT2peWPbkshumMFRHdGK27iVJI35zJ/T4Wtrp\nswCAWLtY07riH+CZYRmsOKwnsDJ09K5FDIDp0p/LjUXdMebGxPL2kYTnhU8uZAUDAOhBpM6V7uGJ\ndxeEU9uiBFGfqgyDAAjVGl8okBxsOfRcNGQeCgCqo9TCetR+MROEahl4HRSpn5EUMTaNWJ4AAEZq\ni08oZLxwvSxajZtZW5U/8lAEJtKocy8TlWfLKoVT/RHwjGGrClEfJNiNVU0Rs0/vfi9hnx9NEo7R\nyo0d+tdAneGfGmtzfBgvM0wZL1QWAFTE428nq8Xk1lB/5LQkpqG2a7ehH/9iMzM7BWZmK7f0l5mZ\n2eo9d0IWz5RIACxJKakCWpBdDcSk9NW00EuaFQCC6RY+LWpzZlESAbBUaJS27UjeijDlcu+mmtxf\nTY6T7ZoL1bHS7t1hmRbXiyDbetCrPTJSmVjCfHn1FJPIBZot6fqzUVfKycGhZWLSfq8VS3SXmAIz\nIxHh7qrKSE/j5rPQiD3K2+b0LMBi38Q3YYy32BBq93xQugwww5TWb6LPsp1FoMIoA+W7q3tcWi/+\nylJjTCGy56BPmDXDYUZp11pmA7Z239ykhEr2v+oUdqweUPTZrQ2tw/baYrN5iLHmA89Fw+gTMKPY\n7jfBAAj64EwQaufE97BIZ/yrAqhazDMBgML85ohYQ8FMHJFq+YCRtkPizZ/11bK+EqsuBqbLF3JC\n5qJPS3uQ+JZSG5t2nceZmv1lz2Y/aISovbo7+EUn5/8dNF/MMsthuuofWPk+grnCV9UAAAAASUVO\nRK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAdElEQVR4nN2RwQ3DQAgEF0QLKSBN\nW3J1KSAd+E6MH3yIpeRekaLwHRYGIWCwK9QqtDMA14f6I1jHm3vvcrcGZx49cWhWBgl7PowGjfsN\nK7jYSV49bWm7HPtWSMBgu2Y2BlBC4TH7uBkvttl9M2vJz/3zS/AEyEI1cT4YbqcAAAAASUVORK5C\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAB+0lEQVR4nE2Sv0vVURiHn/ecc00l\nHZJEooakBCFpMKGCWgIbowgiGhqClsaGlvoDnKLBqWhoiaCIhqDFVgeVwH4MZUUE0r2aXpWr3r7n\nnE/D9171Hd/n8OF9n/Paial+pe3l+bcvV0wApkOnRoYH+PBwkQklScqq3sABjsOLylLSXA+flSXl\noqnpFhwsYjOmWOiWG8QA8+73cwCy+/HEe++8MUYrdOsaRqsq9xckRb2iqixFTRBcG3qGo3LSO/cF\nIc8byOxUjwdwbg0By99Ju4zjJBN1twaIRn0PMk4jYCmsArCvs+lRmRyK/qt4jJqrYbg88KAjppQk\niYJHA8mAP2EZwOnu9anZb9XaZkHv6L2z2YNR45KypJbDRr1W3VTZkc6EWrm8yymb7+oGEh6AuBJW\nigqAqLRmzQoAsrVG2KgflIHx89daM1YODB1x2Qxk6w16vyopa+OyK912nX+tJClpvhM/o6Sop3jz\nIQTDuCNJUdO4VEeIGUwpxijzYXKSBGzhKBWttt0pimd4QRPHEgDFrtrMQhUg7cCOPeKphNJ/G+5H\nbeQY6csG3Tj+lt/S0gLAOMIx1A8XFZU0O7h7Q8wpSVk3HVsoKY5+ui3XSj02jEHiJPTMlO/Wj+LK\n8zqnJCnqcbCN8Stjfd36N7dUzpT5+OJCb9heb77/DyMoK+v5ApzFAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACkklEQVR4nEWQS0wTURiFz71zZ9pp\n7YNCnwJCoSCiSI1BE8TgyoWJYkhMdKM73Bq3rnRndCdLY4whRgxR4wYWGAJBJIAYAbVByqMFoRZK\n6ZR2pp1eF03r2X75v5z/ACCiEW4ZAARmq7FRlENAwA3HMl22vC8eNZmSS10srhrGU6oOzsDr6/jM\nizOyWLl/kM+maa0jPDevUgiCStDbmvsxNeUH11lRpvYPWJ0TRN0Dw8wY7Z7NJCwC4xwAz4rHr1cM\nplQAFBsaWVc2VAYQSikVDOIpzxvlnBNGgcHvau141VqvSUVpYVOXPeKVtueTlDIkjLuhSJ83lgkA\nAGgNL8i5+Z/ctQIC4vC3dW71BLih9N7YZuBWIpUjnKEhuVx7Z9opkhJTteXJNbcvGQEBCMydD05b\nyrsou5nYbarxXIzBecG7OPqo7ASOrCzsmlezjIDhqn2V37fovKTNk7nXeW9U0lMAAFtPYTmRL/Bi\nNP3Xu/4OGQAYmMeZeyu2m4XiIU9ze/JpsHdowahSNFW13d32yYdKqU/a7JTPEqc9rREg0CDlHp5I\npf2lRrPDU99qM1t/QeGKhdsGx8LuMsM6u5eY/h4HKFD4PRS60QheYqEcGSFN3ScZADgD1eKHBC/n\nMB75ZLJJVjcYLp/Pjeebrf9HkD8O7FyaEbQdUBwOv68aoopeYllNarmWzygawDAByRZcqrCUJhJp\nc3Q06vujCAWGBou98clRu00EwEEKEZgq1yr6Xn6WVQpuqvaFuz3bYc5BCKjX5bPsWUckz65CgJZ6\n1009aNfNwGGWmvKGL3PKM+EgrYPBFQ231z3+erGVhsJxVazyJRfXUjuyKGVAAArqCC4dOGxptcYv\nzbP1fV0nFqgq/gGUOR1qaywUwwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAfElEQVR4nO2SsRGAIAxFfwAbt3AF\n9nA4S53BzoHcwgbkW0i8sxA9alPl8iEvHyLEc5iCVhZd1MxKTrhrSUpMN+X2W98lAyCZdWnT/VCD\nmYEkA2c0etNlYlAkBJb3gQQXnNjjByu/+CbWP7wbc/vNnwgDP+hnl9ekesHqfR5wySupiGFfFgAA\nAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABa0lEQVR4nG2Sz0pCQRSHfzMjtlBw\nJQQiZUQQgQuFCtpE+AAtqwdo3YP0CC3aBEFtKiIICmlRm1ZFtMnUW9d/pYaais7MaeH1ekc7u+Gb\n78z5zQwTClhcX4lNhwJ+HynZa7ea9VKxYFlVC0DquKZpsroXfmw+SSIllR5u0FopKaWqxMBzV7+a\nuOCMYVCMcS6EaB9mAWA5q/7pWpxhABfYsCdZ5wwA14rfXjYwXo1z5xi+mpkws7MAOAD9WFJjYt/O\nORDyuTUGW/dsCFHpjcHmHbmw2jcZ1dNwYUebsHbTGsGmNDwqHrARrBmQlU9eabRMvHgzfu37Bzfg\nAwCUjWkL187SiWJMO7cNL+z/eGkwvsQ8EDVDjWyRF5pZwqmQJwqYl4FHdzxRRFoaDyYfAtw142Fh\nqGJ+T7vNdvPK/J3aSrjmW5czrTQRAURaKYocRdw+qdOqqUprbTgmIywkk/FoKDglG992PvP+YX8C\nf+vuHv7PB1y2AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAACGklEQVR4nF3Sy2sTURQG8O/c3Jm0\nk+mYJn2lUGtjrGjUClbUoFBB8Ilu6gN06UJcuBBciODf4DY70ZUrxQqKRKRIwdoibQ2NWvqgFU2b\nkqbQNpPJ5B4XUiH3bH98cM7HIdSP5JqIxnNeIFgug+qN+Iy8+nMzkZSZ19aorMemjQf5C4GmQNnb\nyBwaFfVY2Tfc0hKWZMJJPIeGUnm7KgSWRulrKq7h1vfunQAYU3uvNBU1DJ948SrogxCJJkbWNVyf\nvhiGAPk9S5s2a2eK5GlWzKzyj64FtYWEivQ/dMFMSA7s0FAZn85aLkCqPTZ2H1oJjTR21AaB8n7h\ni35ndeBtxGCAO8xSwdSSnnW7azMEJWbCrR3jWtKYefo7pABshFMLCxqK9cQQCAKdoe4fpBev7POK\nAK/t3Yco/0ciAKJ2cKImGGzOTcml7W2lyQwQY/JuukBM2J1qv7GNpJp7IYhbVrgvBED9KQ8FIQHY\nDVt3crPLUI5bjK8eaQShttVzLA0pmL3L+++ZqxPvRW7cTnOKADaaMy9FhGSo9frNLthMxdnMr5OD\nBhPYN564b0rz0imeeuzCYqWs/gNBASWgRC6GufJ8mdDmH6/eGjQMoCZ8JQM+5ORi77m1rqyQKPA3\ncyRYvVR1RMCA54awMuw+W/WzpAgQdsUKG329h53Pgfiepexawf9YKRGpfx9PYGLAMZ1Oa3m62hBb\nrBED+AvSytWQDQrL1wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAAAwElEQVR4nMWRMVIDMQxFnx1tQ8nQ\nQ8sF6LhMityHkoYZjsMtSMtwAvjrn8LZxOvspqFAlew3epJlmCLzYXkWmStxFUaTjxo91eQe3kZ7\nmkHz/uBU68rzY1lv+OJf261okyadbi4HOmUqVb9q/icYGwCXZTguXh/hEzh9fSYvUdv222wZBK91\nfQUUPyvaDDmnFSgQjk5rCYiAYJBaKIYIIO0A7u474f77nG/dxbbqA0KD1DZVDBGqAyFH91AL/eVX\nDmYvYCHQGAOtAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABdUlEQVR4nHXSv0oDQRAG8G93T/FP\no4JdSKGNrYioESGN2CiireJDiC9gJVYiiKVgI3aWprDwCVKIBkI0EQUlFqKixtztzmdx3uWSw6lm\n58fMsOwqtMVwLj81OmTfn+5LpUopAQpzp3XG4bictMwrRawTUpzzWcsmOjWW3ihRo+Vx20KDlRYK\n19ChB7QxzkMnkdivG0kuSoR4lXMwPrUjBEetiu1A4qqq+A8Cn2VES4NOVO4tytDoRCYKX6mxrQJ/\n0miiER+pnUBXlLz6KTQ9UedLeqzXDxXiYxM6zOPoy4YFQRmeVjQmJoWRDBQAeigCnjIWyghIAAp5\niAZAXbuA03u1s9VuK0LtGWOQD1+FKHxoIqDwenMi0wvAYPKbQlKcHYcGdmh9ko1qYXd9ZqFIR9IG\n3A7vsVGnNIPocwhd4Gj/zGBw645C2/zxA993JHk5Cx3e0Cj0Lp48R78uqBzm9J8pQBlHDM1Mjw00\nPx9uizcNaOUAAL8gPehHpFwdiAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i_folder, folder in enumerate(test_folders):\n", + " \n", + "# if i_folder > 0:\n", + "# break\n", + " \n", + " for i_image, image_file in enumerate(os.listdir(folder)):\n", + " if i_image > 2:\n", + " break\n", + " \n", + "# print(folder + \"/\" + image_file)\n", + " display(Image(open(folder + \"/\" + image_file, 'rb').read()))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "PBdkjESPK8tw", + "raw_mimetype": "text/markdown" + }, + "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": 5, + "metadata": { + "cellView": "both", + "code_folding": [], + "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" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "notMNIST_large/A.pickle already present - Skipping pickling.\n", + "notMNIST_large/B.pickle already present - Skipping pickling.\n", + "notMNIST_large/C.pickle already present - Skipping pickling.\n", + "notMNIST_large/D.pickle already present - Skipping pickling.\n", + "notMNIST_large/E.pickle already present - Skipping pickling.\n", + "notMNIST_large/F.pickle already present - Skipping pickling.\n", + "notMNIST_large/G.pickle already present - Skipping pickling.\n", + "notMNIST_large/H.pickle already present - Skipping pickling.\n", + "notMNIST_large/I.pickle already present - Skipping pickling.\n", + "notMNIST_large/J.pickle already present - Skipping pickling.\n", + "notMNIST_small/A.pickle already present - Skipping pickling.\n", + "notMNIST_small/B.pickle already present - Skipping pickling.\n", + "notMNIST_small/C.pickle already present - Skipping pickling.\n", + "notMNIST_small/D.pickle already present - Skipping pickling.\n", + "notMNIST_small/E.pickle already present - Skipping pickling.\n", + "notMNIST_small/F.pickle already present - Skipping pickling.\n", + "notMNIST_small/G.pickle already present - Skipping pickling.\n", + "notMNIST_small/H.pickle already present - Skipping pickling.\n", + "notMNIST_small/I.pickle already present - Skipping pickling.\n", + "notMNIST_small/J.pickle already present - Skipping pickling.\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", + " image_index = 0\n", + " print(folder)\n", + " for image in os.listdir(folder):\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", + " image_index += 1\n", + " except IOError as e:\n", + " print('Could not read:', image_file, ':', e, '- it\\'s ok, skipping.')\n", + " \n", + " num_images = image_index\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": 131, + "metadata": { + "code_folding": [], + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nO4gj8Y844h3EkfhHHPEO4v8DxHX+mMpbsLwAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n8BbiRPwTTngL8f8BEjtWaliwFUcAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIf4FF7yHuBD/ggveQ/x/x8qh79TUt+8AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAD8CAYAAABXXhlaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "image_size = 28 # Pixel width and height\n", + "pixel_depth = 255.0 # Number of levels per pixel\n", + "\n", + "for i_test, test_set in enumerate(train_datasets):\n", + " \n", + " if i_test > 0:\n", + " break\n", + " \n", + " image_data = pickle.loads(open(test_set, 'rb').read())\n", + " for i_img, img_data in enumerate(image_data):\n", + " \n", + " if i_img > 3:\n", + " break\n", + "\n", + " colors = [str(i/pixel_depth) for i in np.ravel(img_data)]\n", + "\n", + " plt.imshow(img_data)\n", + " plt.show()\n", + "\n" + ] + }, + { + "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": "markdown", + "metadata": {}, + "source": [ + "### Using ABS frequency" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([52909, 52911, 52912, 52911, 52912, 52912, 52912, 52912, 52912, 52911])" + ] + }, + "execution_count": 137, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_training_sets = len(train_datasets)\n", + "\n", + "train_stats = np.empty(shape=num_training_sets, dtype=np.int64)\n", + "\n", + "for i_training_set, training_set_name in enumerate(train_datasets):\n", + " \n", + " letter_data = np.load(training_set_name)\n", + " \n", + " train_stats[i_training_set] = letter_data.shape[0]\n", + "train_stats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using balanced frequency by letter" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 9.99954641, 9.9999244 , 10.0001134 , 9.9999244 ,\n", + " 10.0001134 , 10.0001134 , 10.0001134 , 10.0001134 ,\n", + " 10.0001134 , 9.9999244 ])" + ] + }, + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_stats_perc = 100 * train_stats / np.float(sum(train_stats))\n", + "train_stats_perc" + ] + }, + { + "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": 8, + "metadata": { + "cellView": "both", + "code_folding": [ + 0, + 8 + ], + "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", + "\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": 9, + "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": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-0.5 , -0.49607843, -0.5 , -0.42156863, 0.31568629,\n", + " 0.46470588, -0.30784315, -0.17058824, 0.5 , 0.19803922,\n", + " -0.46470588, 0.20980392, 0.5 , -0.23333333, -0.22941177,\n", + " 0.5 , 0.20980392, -0.46078432, 0.20980392, 0.5 ,\n", + " -0.21372549, -0.43333334, 0.37058824, 0.40980393, -0.33529413,\n", + " -0.5 , -0.49215686, -0.5 ], dtype=float32)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_dataset[0][0]" + ] + }, + { + "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": 142, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP4AAAEKCAYAAAAy4ujqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def letter(i):\n", + " return 'abcdefghij'[i]\n", + "\n", + "plt.imshow(train_dataset[10])\n", + "plt.title(\"Char \" + letter(train_labels[10]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "tIQJaJuwg5Hw" + }, + "source": [ + "Finally, let's save the data for later reuse:" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "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": 144, + "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: 690800503\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": 154, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "set_valid_dataset = set([hash(str(x)) for x in valid_dataset])\n", + "set_test_dataset = set([hash(str(x)) for x in test_dataset])\n", + "set_train_dataset = set([hash(str(x)) for x in train_dataset])" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "valid data set: 10000 set: 9872\n", + "test data set: 10000 set: 9780\n", + "train data set: 200000 set: 187217\n" + ] + } + ], + "source": [ + "print('valid data set: ' + str(len(valid_dataset)) + ' set: ' + str(len(set_valid_dataset)))\n", + "print('test data set: ' + str(len(test_dataset)) + ' set: ' + str(len(set_test_dataset)))\n", + "print('train data set: ' + str(len(train_dataset)) + ' set: ' + str(len(set_train_dataset)))" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "overlap test valid: 9725\n", + "overlap train valid: 186264\n", + "overlap train test: 186064\n" + ] + } + ], + "source": [ + "overlap_test_valid = set_test_dataset - set_valid_dataset\n", + "print('overlap test valid: ' + str(len(overlap_test_valid)))\n", + "\n", + "overlap_train_valid = set_train_dataset - set_valid_dataset\n", + "print('overlap train valid: ' + str(len(overlap_train_valid)))\n", + "\n", + "overlap_train_test = set_train_dataset - set_test_dataset\n", + "print('overlap train test: ' + str(len(overlap_train_test)))" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 79 ms, sys: 2.47 ms, total: 81.5 ms\n", + "Wall time: 80.8 ms\n", + "CPU times: user 74.3 ms, sys: 771 µs, total: 75.1 ms\n", + "Wall time: 75.1 ms\n", + "CPU times: user 1.54 s, sys: 21.3 ms, total: 1.56 s\n", + "Wall time: 1.57 s\n" + ] + } + ], + "source": [ + "from hashlib import md5\n", + "%time set_valid_dataset_2 = set([ md5(x).hexdigest() for x in valid_dataset])\n", + "%time set_test_dataset_2 = set([ md5(x).hexdigest() for x in test_dataset])\n", + "%time set_train_dataset_2 = set([ md5(x).hexdigest() for x in train_dataset])" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "overlap test valid: 9725\n", + "overlap train valid: 186264\n", + "overlap train test: 186064\n" + ] + } + ], + "source": [ + "overlap_test_valid_2 = set_test_dataset_2 - set_valid_dataset_2\n", + "print('overlap test valid: ' + str(len(overlap_test_valid_2)))\n", + "\n", + "overlap_train_valid_2 = set_train_dataset_2 - set_valid_dataset_2\n", + "print('overlap train valid: ' + str(len(overlap_train_valid_2)))\n", + "\n", + "overlap_train_test_2 = set_train_dataset_2 - set_test_dataset_2\n", + "print('overlap train test: ' + str(len(overlap_train_test_2)))" + ] + }, + { + "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": 169, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['train_dataset', 'test_dataset', 'train_labels', 'test_labels', 'valid_labels', 'valid_dataset'])\n" + ] + } + ], + "source": [ + "d = {}\n", + "try:\n", + " with open(pickle_file, 'rb') as f:\n", + " d= pickle.load(f)\n", + " locals().update(save)\n", + "except Exception as e:\n", + " print(e)\n", + "print(d.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "200000" + ] + }, + "execution_count": 170, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(train_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegressionCV\n", + "\n", + "logregCV = LogisticRegressionCV()" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "flat_train_dataset_50 = [x.flatten() for x in train_dataset[:50]]\n", + "flat_train_dataset_100 = [x.flatten() for x in train_dataset[:100]]\n", + "flat_train_dataset_1000 = [x.flatten() for x in train_dataset[:1000]]\n", + "flat_train_dataset_5000 = [x.flatten() for x in train_dataset[:5000]]" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/site-packages/sklearn/cross_validation.py:516: Warning: The least populated class in y has only 2 members, which is too few. The minimum number of labels for any class cannot be less than n_folds=3.\n", + " % (min_labels, self.n_folds)), Warning)\n" + ] + } + ], + "source": [ + "model_50 = logregCV.fit(flat_train_dataset_50, train_labels[:50])\n", + "model_100 = logregCV.fit(flat_train_dataset_100, train_labels[:100])\n", + "model_1000 = logregCV.fit(flat_train_dataset_1000, train_labels[:1000])\n", + "model_5000 = logregCV.fit(flat_train_dataset_5000, train_labels[:5000])" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/site-packages/sklearn/cross_validation.py:516: Warning: The least populated class in y has only 2 members, which is too few. The minimum number of labels for any class cannot be less than n_folds=3.\n", + " % (min_labels, self.n_folds)), Warning)\n", + "/usr/local/lib/python3.5/site-packages/sklearn/cross_validation.py:516: Warning: The least populated class in y has only 1 members, which is too few. The minimum number of labels for any class cannot be less than n_folds=3.\n", + " % (min_labels, self.n_folds)), Warning)\n", + "/usr/local/lib/python3.5/site-packages/sklearn/cross_validation.py:516: Warning: The least populated class in y has only 1 members, which is too few. The minimum number of labels for any class cannot be less than n_folds=3.\n", + " % (min_labels, self.n_folds)), Warning)\n", + "/usr/local/lib/python3.5/site-packages/sklearn/cross_validation.py:516: Warning: The least populated class in y has only 2 members, which is too few. The minimum number of labels for any class cannot be less than n_folds=3.\n", + " % (min_labels, self.n_folds)), Warning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "in sample cross validation scores \n", + "0.348223499926\n", + "0.532793882592\n", + "0.778022019862\n", + "0.818601800147\n" + ] + } + ], + "source": [ + "from sklearn.cross_validation import cross_val_score\n", + "\n", + "score_50 = cross_val_score(model_50, flat_train_dataset_50, train_labels[:50]).mean()\n", + "score_100 = cross_val_score(model_100, flat_train_dataset_100, train_labels[:100]).mean()\n", + "score_1000 = cross_val_score(model_1000, flat_train_dataset_1000, train_labels[:1000]).mean()\n", + "score_5000 = cross_val_score(model_5000, flat_train_dataset_5000, train_labels[:5000]).mean()\n", + "\n", + "print ('in sample cross validation scores ')\n", + "print (score_50)\n", + "print (score_100)\n", + "print (score_1000)\n", + "print (score_5000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Raw Cell Format", + "colab": { + "default_view": {}, + "name": "1_notmnist.ipynb", + "provenance": [], + "version": "0.3.2", + "views": {} + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/2_fullyconnected.ipynb b/2_fullyconnected.ipynb new file mode 100644 index 0000000..1e9ca34 --- /dev/null +++ b/2_fullyconnected.ipynb @@ -0,0 +1,777 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "kR-4eNdK6lYS" + }, + "source": [ + "Deep Learning\n", + "=============\n", + "\n", + "Assignment 2\n", + "------------\n", + "\n", + "Previously in `1_notmnist.ipynb`, we created a pickle with formatted datasets for training, development and testing on the [notMNIST dataset](http://yaroslavvb.blogspot.com/2011/09/notmnist-dataset.html).\n", + "\n", + "The goal of this assignment is to progressively train deeper and more accurate models using TensorFlow." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "cellView": "both", + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "collapsed": true, + "id": "JLpLa8Jt7Vu4" + }, + "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 numpy as np\n", + "import tensorflow as tf\n", + "from six.moves import cPickle as pickle\n", + "from six.moves import range" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "1HrCK6e17WzV" + }, + "source": [ + "First reload the data we generated in `1_notmnist.ipynb`." + ] + }, + { + "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": 19456, + "status": "ok", + "timestamp": 1449847956073, + "user": { + "color": "", + "displayName": "", + "isAnonymous": false, + "isMe": true, + "permissionId": "", + "photoUrl": "", + "sessionId": "0", + "userId": "" + }, + "user_tz": 480 + }, + "id": "y3-cj1bpmuxc", + "outputId": "0ddb1607-1fc4-4ddb-de28-6c7ab7fb0c33" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training set (200000, 28, 28) (200000,)\n", + "Validation set (10000, 28, 28) (10000,)\n", + "Test set (10000, 28, 28) (10000,)\n" + ] + } + ], + "source": [ + "pickle_file = 'notMNIST.pickle'\n", + "\n", + "with open(pickle_file, 'rb') as f:\n", + " save = pickle.load(f)\n", + " train_dataset = save['train_dataset']\n", + " train_labels = save['train_labels']\n", + " valid_dataset = save['valid_dataset']\n", + " valid_labels = save['valid_labels']\n", + " test_dataset = save['test_dataset']\n", + " test_labels = save['test_labels']\n", + " del save # hint to help gc free up memory\n", + " print('Training set', train_dataset.shape, train_labels.shape)\n", + " print('Validation set', valid_dataset.shape, valid_labels.shape)\n", + " print('Test set', test_dataset.shape, test_labels.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "L7aHrm6nGDMB" + }, + "source": [ + "Reformat into a shape that's more adapted to the models we're going to train:\n", + "- data as a flat matrix,\n", + "- labels as float 1-hot encodings." + ] + }, + { + "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": 19723, + "status": "ok", + "timestamp": 1449847956364, + "user": { + "color": "", + "displayName": "", + "isAnonymous": false, + "isMe": true, + "permissionId": "", + "photoUrl": "", + "sessionId": "0", + "userId": "" + }, + "user_tz": 480 + }, + "id": "IRSyYiIIGIzS", + "outputId": "2ba0fc75-1487-4ace-a562-cf81cae82793" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training set (200000, 784) (200000, 10)\n", + "Validation set (10000, 784) (10000, 10)\n", + "Test set (10000, 784) (10000, 10)\n" + ] + } + ], + "source": [ + "image_size = 28\n", + "num_labels = 10\n", + "\n", + "def reformat(dataset, labels):\n", + " dataset = dataset.reshape((-1, image_size * image_size)).astype(np.float32)\n", + " # Map 0 to [1.0, 0.0, 0.0 ...], 1 to [0.0, 1.0, 0.0 ...]\n", + " labels = (np.arange(num_labels) == labels[:,None]).astype(np.float32)\n", + " return dataset, labels\n", + "train_dataset, train_labels = reformat(train_dataset, train_labels)\n", + "valid_dataset, valid_labels = reformat(valid_dataset, valid_labels)\n", + "test_dataset, test_labels = reformat(test_dataset, test_labels)\n", + "print('Training set', train_dataset.shape, train_labels.shape)\n", + "print('Validation set', valid_dataset.shape, valid_labels.shape)\n", + "print('Test set', test_dataset.shape, test_labels.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "nCLVqyQ5vPPH" + }, + "source": [ + "We're first going to train a multinomial logistic regression using simple gradient descent.\n", + "\n", + "TensorFlow works like this:\n", + "* First you describe the computation that you want to see performed: what the inputs, the variables, and the operations look like. These get created as nodes over a computation graph. This description is all contained within the block below:\n", + "\n", + " with graph.as_default():\n", + " ...\n", + "\n", + "* Then you can run the operations on this graph as many times as you want by calling `session.run()`, providing it outputs to fetch from the graph that get returned. This runtime operation is all contained in the block below:\n", + "\n", + " with tf.Session(graph=graph) as session:\n", + " ...\n", + "\n", + "Let's load all the data into TensorFlow and build the computation graph corresponding to our training:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "cellView": "both", + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "collapsed": true, + "id": "Nfv39qvtvOl_" + }, + "outputs": [], + "source": [ + "# With gradient descent training, even this much data is prohibitive.\n", + "# Subset the training data for faster turnaround.\n", + "train_subset = 10000\n", + "\n", + "graph = tf.Graph()\n", + "with graph.as_default():\n", + "\n", + " # Input data.\n", + " # Load the training, validation and test data into constants that are\n", + " # attached to the graph.\n", + " tf_train_dataset = tf.constant(train_dataset[:train_subset, :])\n", + " tf_train_labels = tf.constant(train_labels[:train_subset])\n", + " tf_valid_dataset = tf.constant(valid_dataset)\n", + " tf_test_dataset = tf.constant(test_dataset)\n", + " \n", + " # Variables.\n", + " # These are the parameters that we are going to be training. The weight\n", + " # matrix will be initialized using random valued following a (truncated)\n", + " # normal distribution. The biases get initialized to zero.\n", + " weights = tf.Variable(\n", + " tf.truncated_normal([image_size * image_size, num_labels]))\n", + " biases = tf.Variable(tf.zeros([num_labels]))\n", + " \n", + " # Training computation.\n", + " # We multiply the inputs with the weight matrix, and add biases. We compute\n", + " # the softmax and cross-entropy (it's one operation in TensorFlow, because\n", + " # it's very common, and it can be optimized). We take the average of this\n", + " # cross-entropy across all training examples: that's our loss.\n", + " logits = tf.matmul(tf_train_dataset, weights) + biases\n", + " loss = tf.reduce_mean(\n", + " tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels))\n", + " \n", + " # Optimizer.\n", + " # We are going to find the minimum of this loss using gradient descent.\n", + " optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)\n", + " \n", + " # Predictions for the training, validation, and test data.\n", + " # These are not part of training, but merely here so that we can report\n", + " # accuracy figures as we train.\n", + " train_prediction = tf.nn.softmax(logits)\n", + " valid_prediction = tf.nn.softmax(\n", + " tf.matmul(tf_valid_dataset, weights) + biases)\n", + " test_prediction = tf.nn.softmax(tf.matmul(tf_test_dataset, weights) + biases)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "KQcL4uqISHjP" + }, + "source": [ + "Let's run this computation and iterate:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "cellView": "both", + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "output_extras": [ + { + "item_id": 9 + } + ] + }, + "colab_type": "code", + "collapsed": false, + "executionInfo": { + "elapsed": 57454, + "status": "ok", + "timestamp": 1449847994134, + "user": { + "color": "", + "displayName": "", + "isAnonymous": false, + "isMe": true, + "permissionId": "", + "photoUrl": "", + "sessionId": "0", + "userId": "" + }, + "user_tz": 480 + }, + "id": "z2cjdenH869W", + "outputId": "4c037ba1-b526-4d8e-e632-91e2a0333267" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized\n", + "Loss at step 0: 22.861370\n", + "Training accuracy: 4.2%\n", + "Validation accuracy: 6.7%\n", + "Loss at step 100: 2.256222\n", + "Training accuracy: 71.4%\n", + "Validation accuracy: 70.2%\n", + "Loss at step 200: 1.818203\n", + "Training accuracy: 74.7%\n", + "Validation accuracy: 72.6%\n", + "Loss at step 300: 1.576893\n", + "Training accuracy: 76.3%\n", + "Validation accuracy: 73.5%\n", + "Loss at step 400: 1.414276\n", + "Training accuracy: 77.3%\n", + "Validation accuracy: 74.2%\n", + "Loss at step 500: 1.295093\n", + "Training accuracy: 78.1%\n", + "Validation accuracy: 74.5%\n", + "Loss at step 600: 1.202376\n", + "Training accuracy: 78.9%\n", + "Validation accuracy: 74.7%\n", + "Loss at step 700: 1.127377\n", + "Training accuracy: 79.4%\n", + "Validation accuracy: 75.0%\n", + "Loss at step 800: 1.065220\n", + "Training accuracy: 79.7%\n", + "Validation accuracy: 75.3%\n", + "Test accuracy: 82.0%\n" + ] + } + ], + "source": [ + "num_steps = 801\n", + "\n", + "def accuracy(predictions, labels):\n", + " return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1))\n", + " / predictions.shape[0])\n", + "\n", + "with tf.Session(graph=graph) as session:\n", + " # This is a one-time operation which ensures the parameters get initialized as\n", + " # we described in the graph: random weights for the matrix, zeros for the\n", + " # biases. \n", + " tf.initialize_all_variables().run()\n", + " print('Initialized')\n", + " for step in range(num_steps):\n", + " # Run the computations. We tell .run() that we want to run the optimizer,\n", + " # and get the loss value and the training predictions returned as numpy\n", + " # arrays.\n", + " _, l, predictions = session.run([optimizer, loss, train_prediction])\n", + " if (step % 100 == 0):\n", + " print('Loss at step %d: %f' % (step, l))\n", + " print('Training accuracy: %.1f%%' % accuracy(\n", + " predictions, train_labels[:train_subset, :]))\n", + " # Calling .eval() on valid_prediction is basically like calling run(), but\n", + " # just to get that one numpy array. Note that it recomputes all its graph\n", + " # dependencies.\n", + " print('Validation accuracy: %.1f%%' % accuracy(\n", + " valid_prediction.eval(), valid_labels))\n", + " print('Test accuracy: %.1f%%' % accuracy(test_prediction.eval(), test_labels))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "x68f-hxRGm3H" + }, + "source": [ + "Let's now switch to stochastic gradient descent training instead, which is much faster.\n", + "\n", + "The graph will be similar, except that instead of holding all the training data into a constant node, we create a `Placeholder` node which will be fed actual data at every call of `sesion.run()`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "cellView": "both", + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "collapsed": true, + "id": "qhPMzWYRGrzM" + }, + "outputs": [], + "source": [ + "batch_size = 128\n", + "\n", + "graph = tf.Graph()\n", + "with graph.as_default():\n", + "\n", + " # Input data. For the training data, we use a placeholder that will be fed\n", + " # at run time with a training minibatch.\n", + " tf_train_dataset = tf.placeholder(tf.float32,\n", + " shape=(batch_size, image_size * image_size))\n", + " tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))\n", + " tf_valid_dataset = tf.constant(valid_dataset)\n", + " tf_test_dataset = tf.constant(test_dataset)\n", + " \n", + " # Variables.\n", + " weights = tf.Variable(\n", + " tf.truncated_normal([image_size * image_size, num_labels]))\n", + " biases = tf.Variable(tf.zeros([num_labels]))\n", + " \n", + " # Training computation.\n", + " logits = tf.matmul(tf_train_dataset, weights) + biases\n", + " loss = tf.reduce_mean(\n", + " tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels))\n", + " \n", + " # Optimizer.\n", + " optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)\n", + " \n", + " # Predictions for the training, validation, and test data.\n", + " train_prediction = tf.nn.softmax(logits)\n", + " valid_prediction = tf.nn.softmax(\n", + " tf.matmul(tf_valid_dataset, weights) + biases)\n", + " test_prediction = tf.nn.softmax(tf.matmul(tf_test_dataset, weights) + biases)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "XmVZESmtG4JH" + }, + "source": [ + "Let's run it:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "cellView": "both", + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + }, + "output_extras": [ + { + "item_id": 6 + } + ] + }, + "colab_type": "code", + "collapsed": false, + "executionInfo": { + "elapsed": 66292, + "status": "ok", + "timestamp": 1449848003013, + "user": { + "color": "", + "displayName": "", + "isAnonymous": false, + "isMe": true, + "permissionId": "", + "photoUrl": "", + "sessionId": "0", + "userId": "" + }, + "user_tz": 480 + }, + "id": "FoF91pknG_YW", + "outputId": "d255c80e-954d-4183-ca1c-c7333ce91d0a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized\n", + "Minibatch loss at step 0: 22.285925\n", + "Minibatch accuracy: 7.8%\n", + "Validation accuracy: 9.7%\n", + "Minibatch loss at step 500: 1.224837\n", + "Minibatch accuracy: 83.6%\n", + "Validation accuracy: 75.4%\n", + "Minibatch loss at step 1000: 1.492978\n", + "Minibatch accuracy: 78.1%\n", + "Validation accuracy: 76.4%\n", + "Minibatch loss at step 1500: 0.836115\n", + "Minibatch accuracy: 82.8%\n", + "Validation accuracy: 76.6%\n", + "Minibatch loss at step 2000: 0.826144\n", + "Minibatch accuracy: 81.2%\n", + "Validation accuracy: 77.2%\n", + "Minibatch loss at step 2500: 0.947552\n", + "Minibatch accuracy: 76.6%\n", + "Validation accuracy: 78.2%\n", + "Minibatch loss at step 3000: 0.902825\n", + "Minibatch accuracy: 80.5%\n", + "Validation accuracy: 78.7%\n", + "Test accuracy: 86.2%\n" + ] + } + ], + "source": [ + "num_steps = 3001\n", + "\n", + "with tf.Session(graph=graph) as session:\n", + " tf.initialize_all_variables().run()\n", + " print(\"Initialized\")\n", + " for step in range(num_steps):\n", + " # Pick an offset within the training data, which has been randomized.\n", + " # Note: we could use better randomization across epochs.\n", + " offset = (step * batch_size) % (train_labels.shape[0] - batch_size)\n", + " # Generate a minibatch.\n", + " batch_data = train_dataset[offset:(offset + batch_size), :]\n", + " batch_labels = train_labels[offset:(offset + batch_size), :]\n", + " # Prepare a dictionary telling the session where to feed the minibatch.\n", + " # The key of the dictionary is the placeholder node of the graph to be fed,\n", + " # and the value is the numpy array to feed to it.\n", + " feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels}\n", + " _, l, predictions = session.run(\n", + " [optimizer, loss, train_prediction], feed_dict=feed_dict)\n", + " if (step % 500 == 0):\n", + " print(\"Minibatch loss at step %d: %f\" % (step, l))\n", + " print(\"Minibatch accuracy: %.1f%%\" % accuracy(predictions, batch_labels))\n", + " print(\"Validation accuracy: %.1f%%\" % accuracy(\n", + " valid_prediction.eval(), valid_labels))\n", + " print(\"Test accuracy: %.1f%%\" % accuracy(test_prediction.eval(), test_labels))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "7omWxtvLLxik" + }, + "source": [ + "---\n", + "Problem\n", + "-------\n", + "\n", + "Turn the logistic regression example with SGD into a 1-hidden layer neural network with rectified linear units (nn.relu()) and 1024 hidden nodes. This model should improve your validation / test accuracy.\n", + "\n", + "---" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "batch_size = 128\n", + "\n", + "num_hidden_nodes = 1024\n", + "\n", + "graph = tf.Graph()\n", + "with graph.as_default():\n", + "\n", + " # Input data. For the training data, we use a placeholder that will be fed\n", + " # at run time with a training minibatch.\n", + " tf_train_dataset = tf.placeholder(\n", + " tf.float32,\n", + " shape=(batch_size, image_size * image_size)\n", + " )\n", + " tf_train_labels = tf.placeholder(\n", + " tf.float32,\n", + " shape=(batch_size, num_labels)\n", + " )\n", + " tf_valid_dataset = tf.constant(valid_dataset)\n", + " tf_test_dataset = tf.constant(test_dataset)\n", + "\n", + " # Variables.\n", + " weights = tf.Variable(\n", + " tf.truncated_normal([\n", + " image_size * image_size,\n", + " num_labels\n", + " ])\n", + " )\n", + " biases = tf.Variable(tf.zeros([num_labels]))\n", + "\n", + " ''' new hidden layer '''\n", + " \n", + " weights_hidden = tf.Variable(\n", + " tf.truncated_normal([\n", + " image_size * image_size,\n", + " num_hidden_nodes\n", + " ])\n", + " )\n", + " biases_hidden = tf.Variable( tf.zeros([num_hidden_nodes]))\n", + " layer_hidden = tf.nn.relu(\n", + " tf.matmul( tf_train_dataset, weights_hidden) + biases_hidden\n", + " )\n", + "\n", + " # Variables.\n", + " weights = tf.Variable(\n", + " tf.truncated_normal([num_hidden_nodes, num_labels])\n", + " ) \n", + " biases = tf.Variable(tf.zeros([num_labels]))\n", + "\n", + " # Training computation.\n", + " logits = tf.matmul(layer_hidden, weights) + biases\n", + " loss = tf.reduce_mean(\n", + " tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels)\n", + " )\n", + "\n", + " # Optimizer.\n", + " optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)\n", + "\n", + " # Predictions for the training, validation, and test data.\n", + " train_prediction = tf.nn.softmax(logits)\n", + " valid_relu = tf.nn.relu(\n", + " tf.matmul(tf_valid_dataset, weights_hidden) + biases_hidden\n", + " )\n", + " valid_prediction = tf.nn.softmax(\n", + " tf.matmul(valid_relu, weights) + biases\n", + " ) \n", + "\n", + " test_relu = tf.nn.relu(\n", + " tf.matmul( tf_test_dataset, weights_hidden) + biases_hidden\n", + " )\n", + " test_prediction = tf.nn.softmax(\n", + " tf.matmul(test_relu, weights) + biases\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized\n", + "Minibatch loss at step 0: 360.401733\n", + "Minibatch accuracy: 7.8%\n", + "Validation accuracy: 28.9%\n", + "Minibatch loss at step 500: 18.834892\n", + "Minibatch accuracy: 83.6%\n", + "Validation accuracy: 79.7%\n", + "Minibatch loss at step 1000: 11.846828\n", + "Minibatch accuracy: 80.5%\n", + "Validation accuracy: 82.0%\n", + "Minibatch loss at step 1500: 5.055688\n", + "Minibatch accuracy: 86.7%\n", + "Validation accuracy: 79.8%\n", + "Minibatch loss at step 2000: 3.064413\n", + "Minibatch accuracy: 87.5%\n", + "Validation accuracy: 80.7%\n", + "Minibatch loss at step 2500: 3.609368\n", + "Minibatch accuracy: 79.7%\n", + "Validation accuracy: 82.2%\n", + "Minibatch loss at step 3000: 2.302234\n", + "Minibatch accuracy: 78.9%\n", + "Validation accuracy: 82.2%\n", + "Minibatch loss at step 3500: 2.474628\n", + "Minibatch accuracy: 85.9%\n", + "Validation accuracy: 80.2%\n", + "Minibatch loss at step 4000: 3.879146\n", + "Minibatch accuracy: 88.3%\n", + "Validation accuracy: 81.7%\n", + "Minibatch loss at step 4500: 3.509903\n", + "Minibatch accuracy: 86.7%\n", + "Validation accuracy: 81.6%\n", + "Minibatch loss at step 5000: 4.460998\n", + "Minibatch accuracy: 85.2%\n", + "Validation accuracy: 81.8%\n", + "Test accuracy: 89.0%\n" + ] + } + ], + "source": [ + "num_steps = 5001\n", + "\n", + "with tf.Session(graph=graph) as session:\n", + " tf.initialize_all_variables().run()\n", + " print(\"Initialized\")\n", + " for step in range(num_steps):\n", + " # Pick an offset within the training data, which has been randomized.\n", + " # Note: we could use better randomization across epochs.\n", + " offset = (step * batch_size) % (train_labels.shape[0] - batch_size)\n", + " # Generate a minibatch.\n", + " batch_data = train_dataset[offset:(offset + batch_size), :]\n", + " batch_labels = train_labels[offset:(offset + batch_size), :]\n", + " # Prepare a dictionary telling the session where to feed the minibatch.\n", + " # The key of the dictionary is the placeholder node of the graph to be fed,\n", + " # and the value is the numpy array to feed to it.\n", + " feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels}\n", + " _, l, predictions = session.run(\n", + " [optimizer, loss, train_prediction], feed_dict=feed_dict)\n", + " if (step % 500 == 0):\n", + " print(\"Minibatch loss at step %d: %f\" % (step, l))\n", + " print(\"Minibatch accuracy: %.1f%%\" % accuracy(predictions, batch_labels))\n", + " print(\"Validation accuracy: %.1f%%\" % accuracy(\n", + " valid_prediction.eval(), valid_labels))\n", + " print(\"Test accuracy: %.1f%%\" % accuracy(test_prediction.eval(), test_labels))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "default_view": {}, + "name": "2_fullyconnected.ipynb", + "provenance": [], + "version": "0.3.2", + "views": {} + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/3_regularization.ipynb b/3_regularization.ipynb new file mode 100644 index 0000000..83ec174 --- /dev/null +++ b/3_regularization.ipynb @@ -0,0 +1,1138 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "kR-4eNdK6lYS" + }, + "source": [ + "Deep Learning\n", + "=============\n", + "\n", + "Assignment 3\n", + "------------\n", + "\n", + "Previously in `2_fullyconnected.ipynb`, you trained a logistic regression and a neural network model.\n", + "\n", + "The goal of this assignment is to explore regularization techniques." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "cellView": "both", + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "collapsed": true, + "id": "JLpLa8Jt7Vu4" + }, + "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 numpy as np\n", + "import tensorflow as tf\n", + "from six.moves import cPickle as pickle" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "1HrCK6e17WzV" + }, + "source": [ + "First reload the data we generated in _notmist.ipynb_." + ] + }, + { + "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": 11777, + "status": "ok", + "timestamp": 1449849322348, + "user": { + "color": "", + "displayName": "", + "isAnonymous": false, + "isMe": true, + "permissionId": "", + "photoUrl": "", + "sessionId": "0", + "userId": "" + }, + "user_tz": 480 + }, + "id": "y3-cj1bpmuxc", + "outputId": "e03576f1-ebbe-4838-c388-f1777bcc9873" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training set (200000, 28, 28) (200000,)\n", + "Validation set (10000, 28, 28) (10000,)\n", + "Test set (10000, 28, 28) (10000,)\n" + ] + } + ], + "source": [ + "pickle_file = 'notMNIST.pickle'\n", + "\n", + "with open(pickle_file, 'rb') as f:\n", + " save = pickle.load(f)\n", + " train_dataset = save['train_dataset']\n", + " train_labels = save['train_labels']\n", + " valid_dataset = save['valid_dataset']\n", + " valid_labels = save['valid_labels']\n", + " test_dataset = save['test_dataset']\n", + " test_labels = save['test_labels']\n", + " del save # hint to help gc free up memory\n", + " print('Training set', train_dataset.shape, train_labels.shape)\n", + " print('Validation set', valid_dataset.shape, valid_labels.shape)\n", + " print('Test set', test_dataset.shape, test_labels.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "L7aHrm6nGDMB" + }, + "source": [ + "Reformat into a shape that's more adapted to the models we're going to train:\n", + "- data as a flat matrix,\n", + "- labels as float 1-hot encodings." + ] + }, + { + "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": 11728, + "status": "ok", + "timestamp": 1449849322356, + "user": { + "color": "", + "displayName": "", + "isAnonymous": false, + "isMe": true, + "permissionId": "", + "photoUrl": "", + "sessionId": "0", + "userId": "" + }, + "user_tz": 480 + }, + "id": "IRSyYiIIGIzS", + "outputId": "3f8996ee-3574-4f44-c953-5c8a04636582" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training set (200000, 784) (200000, 10)\n", + "Validation set (10000, 784) (10000, 10)\n", + "Test set (10000, 784) (10000, 10)\n" + ] + } + ], + "source": [ + "image_size = 28\n", + "num_labels = 10\n", + "\n", + "def reformat(dataset, labels):\n", + " dataset = dataset.reshape((-1, image_size * image_size)).astype(np.float32)\n", + " # Map 2 to [0.0, 1.0, 0.0 ...], 3 to [0.0, 0.0, 1.0 ...]\n", + " labels = (np.arange(num_labels) == labels[:,None]).astype(np.float32)\n", + " return dataset, labels\n", + "train_dataset, train_labels = reformat(train_dataset, train_labels)\n", + "valid_dataset, valid_labels = reformat(valid_dataset, valid_labels)\n", + "test_dataset, test_labels = reformat(test_dataset, test_labels)\n", + "print('Training set', train_dataset.shape, train_labels.shape)\n", + "print('Validation set', valid_dataset.shape, valid_labels.shape)\n", + "print('Test set', test_dataset.shape, test_labels.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "cellView": "both", + "colab": { + "autoexec": { + "startup": false, + "wait_interval": 0 + } + }, + "colab_type": "code", + "collapsed": true, + "id": "RajPLaL_ZW6w" + }, + "outputs": [], + "source": [ + "def accuracy(predictions, labels):\n", + " return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1))\n", + " / predictions.shape[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "sgLbUAQ1CW-1" + }, + "source": [ + "---\n", + "Problem 1\n", + "---------\n", + "\n", + "Introduce and tune L2 regularization for both logistic and neural network models. Remember that L2 amounts to adding a penalty on the norm of the weights to the loss. In TensorFlow, you can compute the L2 loss for a tensor `t` using `nn.l2_loss(t)`. The right amount of regularization should improve your validation / test accuracy.\n", + "\n", + "---" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "train_subset = 1000\n", + "beta = 0.01\n", + "\n", + "graph = tf.Graph()\n", + "\n", + "with graph.as_default():\n", + " \n", + " tf_train_dataset = tf.constant(\n", + " train_dataset[:train_subset, :]\n", + " )\n", + " tf_train_labels = tf.constant(\n", + " train_labels[:train_subset]\n", + " )\n", + " tf_valid_dataset = tf.constant(valid_dataset)\n", + " tf_test_datast = tf.constant(test_dataset)\n", + " \n", + " ''' variables '''\n", + " weights = tf.Variable(\n", + " tf.truncated_normal([\n", + " image_size * image_size,\n", + " num_labels\n", + " ])\n", + " )\n", + " biases = tf.Variable(tf.zeros([num_labels]))\n", + " \n", + " ''' training computation function '''\n", + " \n", + " logits = tf.matmul(tf_train_dataset, weights) + biases\n", + " \n", + " ''' loss function using L2 Regularization '''\n", + " loss = tf.reduce_mean(\n", + " tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels)\n", + " )\n", + " loss_l2 = tf.reduce_mean(\n", + " loss + beta * tf.nn.l2_loss(weights)\n", + " )\n", + " \n", + " ''' optimize '''\n", + " optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss_l2)\n", + " \n", + " ''' predictions '''\n", + " train_prediction = tf.nn.softmax(logits)\n", + " valid_prediction = tf.nn.softmax(\n", + " tf.matmul(tf_valid_dataset, weights) + biases\n", + " )\n", + " test_prediction = tf.nn.softmax(\n", + " tf.matmul(tf_test_datast, weights) + biases\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "code_folding": [ + 3, + 14 + ], + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized\n", + "Loss at step 0: 18.298470\n", + "Training accuracy: 9.4%\n", + "Validation accuracy: 10.4%\n", + "\n", + "Loss at step 100: 0.866407\n", + "Training accuracy: 82.2%\n", + "Validation accuracy: 68.1%\n", + "\n", + "Loss at step 200: 0.414028\n", + "Training accuracy: 91.5%\n", + "Validation accuracy: 72.4%\n", + "\n", + "Loss at step 300: 0.310625\n", + "Training accuracy: 94.7%\n", + "Validation accuracy: 76.0%\n", + "\n", + "Loss at step 400: 0.286541\n", + "Training accuracy: 95.2%\n", + "Validation accuracy: 77.6%\n", + "\n", + "Loss at step 500: 0.280893\n", + "Training accuracy: 95.4%\n", + "Validation accuracy: 78.4%\n", + "\n", + "Loss at step 600: 0.279271\n", + "Training accuracy: 95.5%\n", + "Validation accuracy: 78.5%\n", + "\n", + "Loss at step 700: 0.278583\n", + "Training accuracy: 95.3%\n", + "Validation accuracy: 78.5%\n", + "\n", + "Loss at step 800: 0.278185\n", + "Training accuracy: 95.4%\n", + "Validation accuracy: 78.6%\n", + "\n", + "Loss at step 900: 0.277924\n", + "Training accuracy: 95.4%\n", + "Validation accuracy: 78.6%\n", + "\n", + "Loss at step 1000: 0.277746\n", + "Training accuracy: 95.4%\n", + "Validation accuracy: 78.6%\n", + "\n", + "Test accuracy: 86.0%\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import pandas as pd\n", + "\n", + "def getTFResults(graph, num_iterations):\n", + "\n", + " def accuracy(predictions, labels):\n", + " return (\n", + " 100.0 * np.sum(\n", + " np.argmax(predictions, 1) == np.argmax(labels, 1)\n", + " ) / predictions.shape[0]\n", + " )\n", + "\n", + " df_accuracy = []\n", + "\n", + " with tf.Session(graph=graph) as session:\n", + " tf.initialize_all_variables().run()\n", + "\n", + " print('Initialized')\n", + "\n", + " for step in range(num_iterations):\n", + " _, l, predictions = session.run([optimizer, loss, train_prediction])\n", + "\n", + " if (step % 100 == 0):\n", + " print('Loss at step %d: %f' % (step, l))\n", + " print(\n", + " 'Training accuracy: %.1f%%' % accuracy(\n", + " predictions,\n", + " train_labels[:train_subset, :]\n", + " )\n", + " )\n", + " print(\n", + " 'Validation accuracy: %.1f%%' % accuracy(\n", + " valid_prediction.eval(),\n", + " valid_labels\n", + " )\n", + " )\n", + " print('')\n", + "\n", + " df_accuracy.append({\n", + " 'step': step,\n", + " 'train': accuracy(\n", + " predictions,\n", + " train_labels[:train_subset, :]\n", + " ),\n", + " 'test': accuracy(\n", + " valid_prediction.eval(),\n", + " valid_labels\n", + " ),\n", + " 'final': accuracy(\n", + " valid_prediction.eval(),\n", + " valid_labels\n", + " )\n", + " })\n", + " print(\n", + " 'Test accuracy: %.1f%%' % accuracy(\n", + " test_prediction.eval(),\n", + " test_labels\n", + " )\n", + " )\n", + "\n", + " df_accuracy.append({\n", + " 'step': step,\n", + " 'final': accuracy(\n", + " valid_prediction.eval(),\n", + " valid_labels\n", + " )\n", + " })\n", + " df_accuracy = pd.DataFrame(df_accuracy)\n", + "\n", + " df_accuracy[['final', 'test', 'train']].plot()\n", + "\n", + "getTFResults(graph, 1001)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "na8xX2yHZzNF" + }, + "source": [ + "---\n", + "Problem 2\n", + "---------\n", + "Let's demonstrate an extreme case of overfitting. Restrict your training data to just a few batches. What happens?\n", + "\n", + "---" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "code_folding": [ + 5 + ], + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized\n", + "Loss at step 0: 19.320166\n", + "Training accuracy: 0.0%\n", + "Validation accuracy: 5.2%\n", + "\n", + "Loss at step 100: 0.035619\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 47.0%\n", + "\n", + "Loss at step 200: 0.035016\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 53.2%\n", + "\n", + "Loss at step 300: 0.038982\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 58.9%\n", + "\n", + "Loss at step 400: 0.041634\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 62.6%\n", + "\n", + "Loss at step 500: 0.042686\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 64.2%\n", + "\n", + "Loss at step 600: 0.042973\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 64.9%\n", + "\n", + "Loss at step 700: 0.043022\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 65.0%\n", + "\n", + "Loss at step 800: 0.043012\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 65.2%\n", + "\n", + "Loss at step 900: 0.042989\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 65.1%\n", + "\n", + "Loss at step 1000: 0.042965\n", + "Training accuracy: 100.0%\n", + "Validation accuracy: 65.1%\n", + "\n", + "Test accuracy: 71.6%\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n0h/xbQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_subset = 100\n", + "beta = 0.01\n", + "\n", + "graph = tf.Graph()\n", + "\n", + "with graph.as_default():\n", + " \n", + " tf_train_dataset = tf.constant(\n", + " train_dataset[:train_subset, :]\n", + " )\n", + " tf_train_labels = tf.constant(\n", + " train_labels[:train_subset]\n", + " )\n", + " tf_valid_dataset = tf.constant(valid_dataset)\n", + " tf_test_datast = tf.constant(test_dataset)\n", + " \n", + " ''' variables '''\n", + " weights = tf.Variable(\n", + " tf.truncated_normal([\n", + " image_size * image_size,\n", + " num_labels\n", + " ])\n", + " )\n", + " biases = tf.Variable(tf.zeros([num_labels]))\n", + " \n", + " ''' training computation function '''\n", + " \n", + " logits = tf.matmul(tf_train_dataset, weights) + biases\n", + " \n", + " ''' loss function using L2 Regularization '''\n", + " loss = tf.reduce_mean(\n", + " tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels)\n", + " )\n", + " loss_l2 = tf.reduce_mean(\n", + " loss + beta * tf.nn.l2_loss(weights)\n", + " )\n", + " \n", + " ''' optimize '''\n", + " optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss_l2)\n", + " \n", + " ''' predictions '''\n", + " train_prediction = tf.nn.softmax(logits)\n", + " valid_prediction = tf.nn.softmax(\n", + " tf.matmul(tf_valid_dataset, weights) + biases\n", + " )\n", + " test_prediction = tf.nn.softmax(\n", + " tf.matmul(tf_test_datast, weights) + biases\n", + " )\n", + " \n", + "getTFResults(graph, 1001)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "ww3SCBUdlkRc" + }, + "source": [ + "---\n", + "Problem 3\n", + "---------\n", + "Introduce Dropout on the hidden layer of the neural network. Remember: Dropout should only be introduced during training, not evaluation, otherwise your evaluation results would be stochastic as well. TensorFlow provides `nn.dropout()` for that, but you have to make sure it's only inserted during training.\n", + "\n", + "What happens to our extreme overfitting case?\n", + "\n", + "---" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "code_folding": [ + 4 + ], + "collapsed": false + }, + "outputs": [], + "source": [ + "batch_size = 128\n", + "beta = 0.001\n", + "\n", + "graph = tf.Graph()\n", + "with graph.as_default():\n", + "\n", + " tf_train_dataset = tf.placeholder(\n", + " tf.float32,\n", + " shape=(batch_size, image_size * image_size)\n", + " )\n", + " tf_train_labels = tf.placeholder(\n", + " tf.float32,\n", + " shape=(batch_size, num_labels)\n", + " )\n", + " tf_valid_dataset = tf.constant(valid_dataset)\n", + " tf_test_datast = tf.constant(test_dataset)\n", + " \n", + " ''' hidden layer '''\n", + " num_nodes_hidden = 1024\n", + " weights_hidden = tf.Variable(\n", + " tf.truncated_normal([\n", + " image_size * image_size,\n", + " num_nodes_hidden\n", + " ])\n", + " )\n", + " biases_hidden = tf.Variable(\n", + " tf.zeros([num_nodes_hidden])\n", + " )\n", + " layer_hidden = tf.nn.relu(\n", + " tf.matmul(\n", + " tf_train_dataset,\n", + " weights_hidden\n", + " ) + biases_hidden\n", + " )\n", + " \n", + " ''' dropout hidden layer '''\n", + " prob_to_keep = tf.placeholder('float')\n", + " layer_drop_hidden = tf.nn.dropout(\n", + " layer_hidden,\n", + " prob_to_keep\n", + " )\n", + " \n", + " ''' variables '''\n", + " weights = tf.Variable(\n", + " tf.truncated_normal([\n", + " num_nodes_hidden,\n", + " num_labels\n", + " ])\n", + " )\n", + " biases = tf.Variable(tf.zeros([num_labels]))\n", + " \n", + " ''' training computation function '''\n", + " logits = tf.matmul(layer_drop_hidden, weights) + biases\n", + " \n", + " ''' loss function using L2 Regularization '''\n", + " loss = tf.reduce_mean(\n", + " tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels)\n", + " )\n", + " loss_l2 = tf.reduce_mean(\n", + " loss + beta * tf.nn.l2_loss(weights)\n", + " )\n", + " \n", + " ''' optimize '''\n", + " optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss_l2)\n", + " \n", + " ''' predictions '''\n", + " train_prediction = tf.nn.softmax(logits)\n", + " valid_relu = tf.nn.relu(\n", + " tf.matmul(\n", + " tf_valid_dataset,\n", + " weights_hidden\n", + " ) + biases_hidden\n", + " )\n", + " valid_prediction = tf.nn.softmax(\n", + " tf.matmul(\n", + " valid_relu,\n", + " weights\n", + " ) + biases\n", + " )\n", + " \n", + " test_relu = tf.nn.relu(\n", + " tf.matmul(\n", + " tf_test_datast,\n", + " weights_hidden\n", + " ) + biases_hidden\n", + " )\n", + " test_prediction = tf.nn.softmax(\n", + " tf.matmul(\n", + " test_relu,\n", + " weights\n", + " ) + biases\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "code_folding": [ + 0 + ], + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized\n", + "Minibatch loss at step 0: 491.942871\n", + "Minibatch loss at step 500: 31.036180\n", + "Minibatch loss at step 1000: 20.925554\n", + "Minibatch loss at step 1500: 13.594889\n", + "Minibatch loss at step 2000: 10.622327\n", + "Minibatch loss at step 2500: 3.022065\n", + "Minibatch loss at step 3000: 4.981676\n", + "Minibatch loss at step 3500: 6.865514\n", + "Minibatch loss at step 4000: 6.325207\n", + "Minibatch loss at step 4500: 4.494231\n", + "Minibatch loss at step 5000: 5.416477\n", + "Minibatch loss at step 5500: 4.110751\n", + "Minibatch loss at step 6000: 2.326210\n", + "Minibatch loss at step 6500: 1.766105\n", + "Minibatch loss at step 7000: 4.448648\n", + "Minibatch loss at step 7500: 2.495820\n", + "Minibatch loss at step 8000: 3.560319\n", + "Minibatch loss at step 8500: 1.192100\n", + "Minibatch loss at step 9000: 3.773134\n", + "Test accuracy: 88.8%\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEACAYAAACj0I2EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def getResults(graph, num_steps, print_while=False):\n", + " results = []\n", + " with tf.Session(graph=graph) as session:\n", + " tf.initialize_all_variables().run()\n", + " print(\"Initialized\")\n", + " for step in range(num_steps):\n", + " # Pick an offset within the training data, which has been randomized.\n", + " # Note: we could use better randomization across epochs.\n", + " offset = (step * batch_size) % (train_labels.shape[0] - batch_size)\n", + " # Generate a minibatch.\n", + " batch_data = train_dataset[offset:(offset + batch_size), :]\n", + " batch_labels = train_labels[offset:(offset + batch_size), :]\n", + "\n", + " feed_dict = {\n", + " tf_train_dataset : batch_data,\n", + " tf_train_labels : batch_labels,\n", + " prob_to_keep : 0.5\n", + " }\n", + " _, l, predictions = session.run( [optimizer, loss_l2, train_prediction], feed_dict=feed_dict)\n", + " if (step % 500 == 0):\n", + " print(\"Minibatch loss at step %d: %f\" % (step, l))\n", + "\n", + " if print_while is True:\n", + " print(\"Minibatch accuracy: %.1f%%\" % accuracy(predictions, batch_labels))\n", + " print(\"Validation accuracy: %.1f%%\" % accuracy( valid_prediction.eval(), valid_labels) )\n", + " print('')\n", + "\n", + " results.append({\n", + " # 'loss': l,\n", + " 'minibatch': accuracy(predictions, batch_labels),\n", + " 'validation': accuracy( valid_prediction.eval(), valid_labels),\n", + " 'test': accuracy(test_prediction.eval(), test_labels)\n", + " })\n", + " print(\"Test accuracy: %.1f%%\" % accuracy(test_prediction.eval(), test_labels))\n", + " return pd.DataFrame(results)\n", + "\n", + "results = getResults(graph, 9001)\n", + "results.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "-b1hTz3VWZjw" + }, + "source": [ + "---\n", + "Problem 4\n", + "---------\n", + "\n", + "Try to get the best performance you can using a multi-layer model! The best reported test accuracy using a deep network is [97.1%](http://yaroslavvb.blogspot.com/2011/09/notmnist-dataset.html?showComment=1391023266211#c8758720086795711595).\n", + "\n", + "One avenue you can explore is to add multiple layers.\n", + "\n", + "Another one is to use learning rate decay:\n", + "\n", + " global_step = tf.Variable(0) # count the number of steps taken.\n", + " learning_rate = tf.train.exponential_decay(0.5, global_step, ...)\n", + " optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)\n", + " \n", + " ---\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Smaller Beta" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "code_folding": [ + 4 + ], + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized\n", + "Minibatch loss at step 0: 495.216187\n", + "Minibatch loss at step 500: 54.948402\n", + "Minibatch loss at step 1000: 20.875557\n", + "Minibatch loss at step 1500: 15.590694\n", + "Minibatch loss at step 2000: 7.621523\n", + "Minibatch loss at step 2500: 5.074099\n", + "Minibatch loss at step 3000: 3.121022\n", + "Test accuracy: 87.4%\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXEAAAEACAYAAABF+UbAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n4kopFcQ0iCulVBD7//tvlD6nePIgAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batch_size = 128\n", + "beta = 0.0001\n", + "\n", + "graph = tf.Graph()\n", + "with graph.as_default():\n", + "\n", + " tf_train_dataset = tf.placeholder(\n", + " tf.float32,\n", + " shape=(batch_size, image_size * image_size)\n", + " )\n", + " tf_train_labels = tf.placeholder(\n", + " tf.float32,\n", + " shape=(batch_size, num_labels)\n", + " )\n", + " tf_valid_dataset = tf.constant(valid_dataset)\n", + " tf_test_datast = tf.constant(test_dataset)\n", + " \n", + " ''' hidden layer '''\n", + " num_nodes_hidden = 1024\n", + " weights_hidden = tf.Variable(\n", + " tf.truncated_normal([\n", + " image_size * image_size,\n", + " num_nodes_hidden\n", + " ])\n", + " )\n", + " biases_hidden = tf.Variable(\n", + " tf.zeros([num_nodes_hidden])\n", + " )\n", + " layer_hidden = tf.nn.relu(\n", + " tf.matmul(\n", + " tf_train_dataset,\n", + " weights_hidden\n", + " ) + biases_hidden\n", + " )\n", + " \n", + " ''' dropout hidden layer '''\n", + " prob_to_keep = tf.placeholder('float')\n", + " layer_drop_hidden = tf.nn.dropout(\n", + " layer_hidden,\n", + " prob_to_keep\n", + " )\n", + " \n", + " ''' variables '''\n", + " weights = tf.Variable(\n", + " tf.truncated_normal([\n", + " num_nodes_hidden,\n", + " num_labels\n", + " ])\n", + " )\n", + " biases = tf.Variable(tf.zeros([num_labels]))\n", + " \n", + " ''' training computation function '''\n", + " logits = tf.matmul(layer_drop_hidden, weights) + biases\n", + " \n", + " ''' loss function using L2 Regularization '''\n", + " loss = tf.reduce_mean(\n", + " tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels)\n", + " )\n", + " loss_l2 = tf.reduce_mean(\n", + " loss + beta * tf.nn.l2_loss(weights)\n", + " )\n", + " \n", + " ''' optimize '''\n", + " optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss_l2)\n", + " \n", + " ''' predictions '''\n", + " train_prediction = tf.nn.softmax(logits)\n", + " valid_relu = tf.nn.relu(\n", + " tf.matmul(\n", + " tf_valid_dataset,\n", + " weights_hidden\n", + " ) + biases_hidden\n", + " )\n", + " valid_prediction = tf.nn.softmax(\n", + " tf.matmul(\n", + " valid_relu,\n", + " weights\n", + " ) + biases\n", + " )\n", + " \n", + " test_relu = tf.nn.relu(\n", + " tf.matmul(\n", + " tf_test_datast,\n", + " weights_hidden\n", + " ) + biases_hidden\n", + " )\n", + " test_prediction = tf.nn.softmax(\n", + " tf.matmul(\n", + " test_relu,\n", + " weights\n", + " ) + biases\n", + " )\n", + " \n", + "results = getResults(graph, 3001)\n", + "results.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized\n", + "Minibatch loss at step 0: 16347.863281\n" + ] + } + ], + "source": [ + "batch_size = 128\n", + "beta = 0.0001\n", + "\n", + "graph = tf.Graph()\n", + "with graph.as_default():\n", + "\n", + " tf_train_dataset = tf.placeholder(\n", + " tf.float32,\n", + " shape=(batch_size, image_size * image_size)\n", + " )\n", + " tf_train_labels = tf.placeholder(\n", + " tf.float32,\n", + " shape=(batch_size, num_labels)\n", + " )\n", + " tf_valid_dataset = tf.constant(valid_dataset)\n", + " tf_test_datast = tf.constant(test_dataset)\n", + " \n", + " ''' hidden layer '''\n", + " num_nodes_hidden = 1024 ** 2\n", + " weights_hidden = tf.Variable(\n", + " tf.truncated_normal([\n", + " image_size * image_size,\n", + " num_nodes_hidden\n", + " ])\n", + " )\n", + " biases_hidden = tf.Variable(\n", + " tf.zeros([num_nodes_hidden])\n", + " )\n", + " layer_hidden = tf.nn.relu(\n", + " tf.matmul(\n", + " tf_train_dataset,\n", + " weights_hidden\n", + " ) + biases_hidden\n", + " )\n", + " \n", + " \n", + " \n", + " ''' dropout hidden layer '''\n", + " prob_to_keep = tf.placeholder('float')\n", + " layer_drop_hidden = tf.nn.dropout(\n", + " layer_hidden,\n", + " prob_to_keep\n", + " )\n", + " \n", + " ''' variables '''\n", + " weights = tf.Variable(\n", + " tf.truncated_normal([\n", + " num_nodes_hidden,\n", + " num_labels\n", + " ])\n", + " )\n", + " biases = tf.Variable(tf.zeros([num_labels]))\n", + " \n", + " ''' training computation function '''\n", + " logits = tf.matmul(layer_drop_hidden, weights) + biases\n", + " \n", + " ''' loss function using L2 Regularization '''\n", + " loss = tf.reduce_mean(\n", + " tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels)\n", + " )\n", + " loss_l2 = tf.reduce_mean(\n", + " loss + beta * tf.nn.l2_loss(weights)\n", + " )\n", + " \n", + " ''' optimize '''\n", + " optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss_l2)\n", + " \n", + " ''' predictions '''\n", + " train_prediction = tf.nn.softmax(logits)\n", + " valid_relu = tf.nn.relu(\n", + " tf.matmul(\n", + " tf_valid_dataset,\n", + " weights_hidden\n", + " ) + biases_hidden\n", + " )\n", + " valid_prediction = tf.nn.softmax(\n", + " tf.matmul(\n", + " valid_relu,\n", + " weights\n", + " ) + biases\n", + " )\n", + " \n", + " test_relu = tf.nn.relu(\n", + " tf.matmul(\n", + " tf_valid_dataset,\n", + " weights_hidden\n", + " ) + biases_hidden\n", + " )\n", + " test_prediction = tf.nn.softmax(\n", + " tf.matmul(\n", + " test_relu,\n", + " weights\n", + " ) + biases\n", + " )\n", + " \n", + "results = getResults(graph, 3001)\n", + "results.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "default_view": {}, + "name": "3_regularization.ipynb", + "provenance": [], + "version": "0.3.2", + "views": {} + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}