diff --git a/notebooks/00_Introduction_solution.ipynb b/notebooks/00_Introduction_solution.ipynb
deleted file mode 100644
index b58d807..0000000
--- a/notebooks/00_Introduction_solution.ipynb
+++ /dev/null
@@ -1,622 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Introduction\n",
- "\n",
- "This notebook shows how to set-up a working python envirnoment for the Machine Learning Practical course.\n",
- "\n",
- "\n",
- "# Setting up the software\n",
- "\n",
- "Within this course we are going to work with python (using some auxiliary libraries like numpy and scipy). Depending on the infrastracture and working environment (e.g. DICE), root permission may not be not available so the packages cannot be installed in default locations. A convenient python configuration, which allows us to install and update third party libraries easily using package manager, are so called virtual environments. They can be also used to work (and test) the code with different versions of software.\n",
- "\n",
- "## Instructions for Windows\n",
- "\n",
- "The fastest way to get working setup on Windows is to install Anaconda (http://www.continuum.io) package. It's a python environment with precompiled versions of the most popular scientific python libraries. It also works on MacOS, but numpy is not linked without a fee to a numerical library, hence for MacOS we recommend the following procedure.\n",
- "\n",
- "## Instructions for MacOS\n",
- "\n",
- " * Install macports following instructions at https://www.macports.org/install.php\n",
- " * Install the relevant python packages in macports\n",
- "\n",
- " ```\n",
- " sudo port install py27-scipy +openblas\n",
- " sudo port install py27-ipython +notebook\n",
- " sudo port install py27-notebook\n",
- " sudo port install py27-matplotlib\n",
- " sudo port select --set python python27\n",
- " sudo port select --set ipython2 py27-ipython\n",
- " sudo port select --set ipython py27-ipython\n",
- " ```\n",
- "\n",
- "Make sure that your `$PATH` has `/opt/local/bin` before `/usr/bin` so you pick up the version of python you just installed.\n",
- "\n",
- "## Instructions for DICE:\n",
- "\n",
- "### Directory structure and getting things organised\n",
- "\n",
- "To get things somehow standarized between people, and make life of everyone easier, we propse to organise your DICE setup in the following directory structure:\n",
- "\n",
- " * `~/mlpractical/` -- for a general course repository\n",
- " * `~/mlpractical/repos-3rd` -- for stuff you download, build and install (numpy, OpenBlas, virtualenv)\n",
- " * `~/mlpractical/repo-mlp` -- this is the actual course repository you clone from our website (do not create a dir for it yet!)\n",
- " * `~/mlpractical/venv` -- this is where virutal envirnoment will make its dir (do not create a dir for it yet!)\n",
- "\n",
- "Create now repos-3rd directory (option -p in the below command will automatically create (non-existing) **p**arent directories (mlpractical):\n",
- "\n",
- " * `mkdir -p ~/mlpractical/repos-3rd`\n",
- "\n",
- "And now, let us set an MLP_WDIR environmental variable (MLP Working DIRectory) that will keep an absolute path of working dir pointing to `~/mlpractial`, **add the below line** to your `~/.bashrc` file (if it does not exists, create one using a text editor! e.g. by running `gedit ~/.bashrc`):\n",
- "\n",
- "```\n",
- "export MLP_WDIR=~/mlpractical\n",
- "```\n",
- "\n",
- "Now re-source `~/.bashrc` by typing (so the env variables get updated!): `source ~/.bashrc`\n",
- "\n",
- "Enter the `repos-3rd` directory by typing: `cd ~/mlpractical/repos-3rd` (or ```cd $MLP_WDIR/repos-3rd``` if you want)\n",
- "\n",
- "### Configuring virtual environment\n",
- "\n",
- "Make sure you are in `repos-3rd` directory and that MLP_WDIR variable has been exported (you may type export in the terminal and examine the list of availabe variables in the current session), then type:\n",
- "\n",
- " * `git clone https://github.com/pypa/virtualenv`\n",
- " * Enter the cloned repository and type ```./virtualenv.py --python /usr/bin/python2.7 --no-site-packages $MLP_WDIR/venv```\n",
- " * Activate the environment by typing `source ~/mlpractical/venv/bin/activate` (to leave the virtual environment one may type `decativate`)\n",
- " * Environments need to be activated every time ones start the new session so we will now create a handy alias to it in `~/.bashrc` script, by typing the below command (note, MLP_WDIR export needs to preceed this command):\n",
- " \n",
- " ```alias activate_mlp=\"source $MLP_WDIR/venv/bin/activate\"```\n",
- " \n",
- "Then every time you open new session and want to activate the right virtual environment, simply type `activate_mlp` instead `source ~/mlpractical/venv/bin/activate`. Note, you need to re-soure the .bashrc in order alias to be visible in the current session.\n",
- "\n",
- "### Installing remaining packages\n",
- "\n",
- "Then, before you follow next, install/upgrade the following packages:\n",
- "\n",
- "```\n",
- "pip install --upgrade pip\n",
- "pip install setuptools\n",
- "pip install setuptools --upgrade\n",
- "pip install ipython\n",
- "pip install notebook\n",
- "```\n",
- "\n",
- "### Installing numpy\n",
- "\n",
- "Note, having virtual environment properly installed one may then run `pip install numpy` to use pip to install numpy, though this will most likely lead to the suboptimal configuration where numpy is linked to ATLAS numerical library, which on DICE is compiled in multi-threaded mode. This means whenever numpy use BLAS accelerated computations (using ATLAS), it will use **all** the available cores at the given machine. This happens because ATLAS can be compiled to either run computations in single *or* multi threaded modes. However, contrary to some other backends, the latter does not allow to use an arbitrary number of threads (specified by the user prior to computation). This is highly suboptimal, as the potential speed-up resulting from paralleism depends on many factors like the communication overhead between threads, the size of the problem, etc. Using all cores for our exercises is not-necessary.\n",
- "\n",
- "For which reason, we are going to compile our own version of BLAS package, called *OpenBlas*. It allows to specify the number of threads manually by setting an environmental variable OMP_NUM_THREADS=N, where N is a desired number of parallel threads (please use 1 by default). You can set an environment variable in the current shell by running\n",
- "\n",
- "```\n",
- "export OMP_NUM_THREADS=1\n",
- "```\n",
- "\n",
- "(note the lack of spaces around the equals sign and use of `export` to define an environment variable which will be available in sub-shells rather than just a variable local to the current shell).\n",
- "\n",
- "#### OpenBlas\n",
- "\n",
- "Enter again repos-3rd directory and copy into terminal the following commands (one at the time):\n",
- "\n",
- "```\n",
- "cd ~/mlpractical/repos-3rd\n",
- "OBDir=$MLP_WDIR/repos-3rd/OpenBLAS\n",
- "git clone git://github.com/xianyi/OpenBLAS\n",
- "cd OpenBLAS\n",
- "make\n",
- "make PREFIX=$OBDir install\n",
- "```\n",
- "\n",
- "Once OpenBLAS is finished compiling we need to ensure the compiled shared library files in the `lib` subdirectory are available to the shared library loader. This can be done by appending the absolute path to the `lib` subdirectory to the `LD_LIBRARY_PATH` environment variable. To ensure this changes persist we will change the bash start up file `~/.bashrc` by opening it in a text editor (e.g. by running `gedit ~/.bashrc`) and adding the following line\n",
- "\n",
- "```\n",
- "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MLP_WDIR/repos-3rd/OpenBLAS/lib\n",
- "```\n",
- "\n",
- "Note, we again are using MLP_WDIR here, so the above line needs to be placed after you set MLP_WDIR.\n",
- "\n",
- "After you have edited `.bashrc` run\n",
- "\n",
- "```\n",
- "source ~/.bashrc\n",
- "activate_mlp # This is the alias you set up in the bashrc\n",
- "#source ~/mlpractical/venv/bin/activate\n",
- "```\n",
- "\n",
- "to rerun the bash start up script make sure the new environment variable is available in the current shell and then reactivate the virtual environment.\n",
- "\n",
- "#### Numpy\n",
- "\n",
- "To install `numpy` linked against the OpenBLAS libraries we just compiled, first run the following commands (one at a time)\n",
- "\n",
- "```\n",
- "cd ~/mlpractical/repos-3rd/\n",
- "wget http://downloads.sourceforge.net/project/numpy/NumPy/1.9.2/numpy-1.9.2.zip\n",
- "unzip numpy-1.9.2.zip\n",
- "cd numpy-1.9.2\n",
- "echo \"[openblas]\" >> site.cfg\n",
- "echo \"library_dirs = $OBDir/lib\" >> site.cfg\n",
- "echo \"include_dirs = $OBDir/include\" >> site.cfg\n",
- "python setup.py build --fcompiler=gnu95\n",
- "```\n",
- "\n",
- "Assuming the virtual environment is activated, the below command will install numpy in a desired space (`~/mlpractical/venv/...`):\n",
- "\n",
- "```\n",
- "python setup.py install\n",
- "```\n",
- "\n",
- "Now use pip to install remaining packages: `scipy`, `matplotlib`, `argparse`, and `nose` by executing:\n",
- "\n",
- "```\n",
- "pip install scipy matplotlib argparse nose\n",
- "```\n",
- "\n",
- "### Getting the mlpractical repository\n",
- "\n",
- "Clone the course repository from the github, by navigating to `~/mlpractical` directory and typing:\n",
- "\n",
- "```\n",
- "cd $MLP_WDIR\n",
- "git clone https://github.com/CSTR-Edinburgh/mlpractical.git repo-mlp\n",
- "```\n",
- "\n",
- "When download is ready, enter the repo-mlp directory and start the actual interactive notebook session by typing:\n",
- "\n",
- "```\n",
- "cd repo-mlp\n",
- "ipython notebook\n",
- "```\n",
- "\n",
- "This should start a ipython server which opens a new browser window listing files in `repo-mlp` directory, including `00_Introduction.ipynb.`. Open it and run (from the browser interface) the following examples and exercies."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false,
- "scrolled": true
- },
- "outputs": [],
- "source": [
- "%clear\n",
- "import numpy\n",
- "# show_config() prints the configuration of numpy numerical backend \n",
- "# you should be able to see linkage to OpenBlas or some other library\n",
- "# in case those are empty, it means something went wrong and \n",
- "# numpy will use a default (slow) pythonic implementation for algebra\n",
- "numpy.show_config()\n",
- "#numpy.test()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Also, below we check whether and how much speedup one may expect by using different number of cores:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "import os\n",
- "import multiprocessing\n",
- "import timeit\n",
- "\n",
- "num_cores = multiprocessing.cpu_count()\n",
- "N = 1000\n",
- "x = numpy.random.random((N,N))\n",
- "\n",
- "for i in xrange(0, num_cores):\n",
- " # first, set the number of threads OpenBLAS\n",
- " # should use, the below line is equivalent\n",
- " # to typing export OMP_NUM_THREADS=i+1 in bash shell\n",
- " print 'Running matrix-matrix product on %i core(s)' % i\n",
- " os.environ['OMP_NUM_THREADS'] = str(i+1)\n",
- " %%timeit numpy.dot(x,x.T)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Test whether you can plot and display the figures using pyplot"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "# Remove the below line if not running this code in an ipython notebook\n",
- "# It's a special command allowing the notebook to display plots inline\n",
- "%matplotlib inline\n",
- "import matplotlib.pyplot as plt\n",
- "\n",
- "x = numpy.linspace(0.0, 2*numpy.pi, 100)\n",
- "y1 = numpy.sin(x)\n",
- "y2 = numpy.cos(x)\n",
- "\n",
- "plt.plot(x, y1, lw=2, label=r'$\\sin(x)$')\n",
- "plt.plot(x, y2, lw=2, label=r'$\\cos(x)$')\n",
- "plt.xlabel('x')\n",
- "plt.ylabel('y')\n",
- "plt.legend()\n",
- "plt.xlim(0.0, 2*numpy.pi)\n",
- "plt.grid()\n",
- "plt.show()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Exercises\n",
- "\n",
- "Today exercises are meant to get you familiar with ipython notebooks (if you haven't used them so far), data organisation and how to access it. Next week onwars, we will follow with the material covered in lectures.\n",
- "\n",
- "## Data providers\n",
- "\n",
- "Open (in the browser) `mlp.dataset` module (go to `Home` tab and navigate to mlp package, then click on the link `dataset.py`). Have a look thourgh the code and comments, then follow to exercises.\n",
- "\n",
- "General note: you can load the mlp code into your favourite python IDE but it is totally OK if you work (modify & save) the code directly in the browser by opening/modyfing the necessary modules in the tabs.\n",
- "\n",
- "### Exercise 1 \n",
- "\n",
- "Using MNISTDataProvider, write a code that iterates over the first 5 minibatches of size 100 data-points. Print MNIST digits in 10x10 images grid plot. Images are returned from the provider as tuples of numpy arrays `(features, targets)`. The `features` matrix has shape BxD while the `targets` vector is of size B, where B is the size of a mini-batch and D is dimensionality of the features. By deafult, each data-point (image) is stored in a 784 dimensional vector of pixel intensities normalised to [0,1] range from an inital integer values [0-255]. However, the original spatial domain is two dimensional, so before plotting you need to convert it into 2D matrix (MNIST images have the same number of pixels for height and width).\n",
- "\n",
- "Tip: Useful functions for this exercise are: imshow, subplot, gridspec"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "%matplotlib inline\n",
- "import matplotlib.pyplot as plt\n",
- "import matplotlib.gridspec as gridspec\n",
- "import matplotlib.cm as cm\n",
- "from mlp.dataset import MNISTDataProvider\n",
- "\n",
- "def show_mnist_image(img):\n",
- " fig = plt.figure()\n",
- " gs = gridspec.GridSpec(1, 1)\n",
- " ax1 = fig.add_subplot(gs[0,0])\n",
- " ax1.imshow(img, cmap=cm.Greys_r)\n",
- " plt.show()\n",
- "\n",
- "def show_mnist_images(batch):\n",
- " feats, tar = batch\n",
- " fig = plt.figure()\n",
- " fif, axarr = plt.subplots(10, 10)\n",
- " for i in xrange(0,10):\n",
- " for j in xrange(0,10):\n",
- " k = i*10 + j\n",
- " axarr[i,j].imshow(feats[k].reshape(28,28), cmap=cm.Greys_r)\n",
- " plt.show()\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "metadata": {
- "collapsed": false,
- "scrolled": true
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n1TP7f52W/XF3cxoRAAAAAElFTkSuQmCC\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMNMcs2aaaaZZAzPNMWummWaaNTD7f1dglqpCKsRxAAAAAElFTkSuQmCC\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/wP4vY1OxyCmaQAAAABJRU5ErkJggg==\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "# An example for a single MNIST image\n",
- "mnist_dp = MNISTDataProvider(dset='valid', batch_size=100, max_num_batches=5, randomize=False)\n",
- "\n",
- "for batch in mnist_dp:\n",
- " features, targets = batch\n",
- " #show_mnist_image(features.reshape(28, 28))\n",
- " show_mnist_images(batch)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Exercise 2\n",
- "\n",
- "`MNISTDataProvider` as `targets` currently returns a vector of integers, each element in this vector represents an id of the category `features` data-point represent. Later in the course we are going to need 1-of-K representation of targets, for instance, given the minibatch of size 3 and the corresponding targets vector $[2, 2, 0]$ (and assuming there are only 3 different classes to discriminate between), one needs to convert it into matrix $\\left[ \\begin{array}{ccc}\n",
- "0 & 0 & 1 \\\\\n",
- "0 & 0 & 1 \\\\\n",
- "1 & 0 & 0 \\end{array} \\right]$. \n",
- "\n",
- "Implement `__to_one_of_k` method of `MNISTDataProvider` class. Then modify (uncomment) an appropriate line in its `next` method, so the raw targets get converted to `1 of K` coding. Test the code in the cell below."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "# %load -r 150:160 mlp/dataset.py\n",
- " return rval_x, self.__to_one_of_k(rval_t) #here we convert the targets to 1-of-K\n",
- "\n",
- " def num_examples(self):\n",
- " return self.x.shape[0]\n",
- " \n",
- " #and here is the function which does it\n",
- " def __to_one_of_k(self, y):\n",
- " rval = numpy.zeros((y.shape[0], self.num_classes), dtype=numpy.float32)\n",
- " for i in xrange(y.shape[0]):\n",
- " rval[i, y[i]] = 1\n",
- " return rval"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "collapsed": true
- },
- "source": [
- "### Exercise 3\n",
- "\n",
- "Write your own data provider `MetOfficeDataProvider` that wraps the weather data for south Scotland (could be obtained from: http://www.metoffice.gov.uk/hadobs/hadukp/data/daily/HadSSP_daily_qc.txt). The file was also downloaded and stored in `data` directory for your convenience. The provider should return a tuple `(x,t)` of the estimates over an arbitrary time windows (i.e. last N-1 days) for `x` and the N-th day as the one which model should be able to predict, `t`. For now, skip missing data-points (denoted by -99.9) and simply use the next correct value. Make sure the provider works for arbitrary `batch_size` settings, including the case where single mini-batch is equal to all datapoints in the dataset. Test the dataset in the cell below.\n",
- "\n",
- "Tip: To follow with this exercise, copy MNISTDataProvider in dataset.py, rename it to `MetOfficeDataProvider` and reimplement necesarry parts (including the arguments you pass to the constructor)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "# %load -s MetOfficeDataProvider mlp/dataset.py\n",
- "class MetOfficeDataProvider(DataProvider):\n",
- " \"\"\"\n",
- " The class iterates over South Scotland Weather, in possibly\n",
- " random order.\n",
- " \"\"\"\n",
- " def __init__(self, window_size,\n",
- " batch_size=10,\n",
- " max_num_batches=-1,\n",
- " max_num_examples=-1,\n",
- " randomize=True):\n",
- "\n",
- " super(MetOfficeDataProvider, self).\\\n",
- " __init__(batch_size, randomize)\n",
- "\n",
- " dset_path = './data/HadSSP_daily_qc.txt'\n",
- " assert os.path.isfile(dset_path), (\n",
- " \"File %s was expected to exist!.\" % dset_path\n",
- " )\n",
- "\n",
- " if max_num_batches > 0 and max_num_examples > 0:\n",
- " logger.warning(\"You have specified both 'max_num_batches' and \" \\\n",
- " \"a deprecead 'max_num_examples' arguments. We will \" \\\n",
- " \"use the former over the latter.\")\n",
- " \n",
- " raw = numpy.loadtxt(dset_path, skiprows=3, usecols=range(2, 32))\n",
- " \n",
- " self.window_size = window_size\n",
- " self._max_num_batches = max_num_batches\n",
- " #max_num_examples arg was provided for backward compatibility\n",
- " #but it maps us to the max_num_batches anyway\n",
- " if max_num_examples > 0 and max_num_batches < 0:\n",
- " self._max_num_batches = max_num_examples / self.batch_size \n",
- " \n",
- " #filter out all missing datapoints and\n",
- " #flatten a matrix to a vector, so we will get\n",
- " #a time preserving representation of measurments\n",
- " #with self.x[0] being the first day and self.x[-1] the last\n",
- " self.x = raw[raw >= 0].flatten()\n",
- " \n",
- " #normalise data to zero mean, unit variance\n",
- " mean = numpy.mean(self.x)\n",
- " var = numpy.var(self.x)\n",
- " assert var >= 0.01, (\n",
- " \"Variance too small %f \" % var\n",
- " )\n",
- " self.x = (self.x-mean)/var\n",
- " \n",
- " self._rand_idx = None\n",
- " if self.randomize:\n",
- " self._rand_idx = self.__randomize()\n",
- "\n",
- " def reset(self):\n",
- " super(MetOfficeDataProvider, self).reset()\n",
- " if self.randomize:\n",
- " self._rand_idx = self.__randomize()\n",
- "\n",
- " def __randomize(self):\n",
- " assert isinstance(self.x, numpy.ndarray)\n",
- " # we generate random indexes starting from window_size, i.e. 10th absolute element\n",
- " # in the self.x vector, as we later during mini-batch preparation slice\n",
- " # the self.x container backwards, i.e. given we want to get a training \n",
- " # data-point for 11th day, we look at 10 preeceding days. \n",
- " # Note, we cannot do this, for example, for the 5th day as\n",
- " # we do not have enough observations to make an input (10 days) to the model\n",
- " return numpy.random.permutation(numpy.arange(self.window_size, self.x.shape[0]))\n",
- "\n",
- " def next(self):\n",
- "\n",
- " has_enough = (self.window_size + self._curr_idx + self.batch_size) <= self.x.shape[0]\n",
- " presented_max = (0 < self._max_num_batches <= (self._curr_idx / self.batch_size))\n",
- "\n",
- " if not has_enough or presented_max:\n",
- " raise StopIteration()\n",
- "\n",
- " if self._rand_idx is not None:\n",
- " range_idx = \\\n",
- " self._rand_idx[self._curr_idx:self._curr_idx + self.batch_size]\n",
- " else:\n",
- " range_idx = \\\n",
- " numpy.arange(self.window_size + self._curr_idx, \n",
- " self.window_size + self._curr_idx + self.batch_size)\n",
- "\n",
- " #build slicing matrix of size minibatch, which will contain batch_size\n",
- " #rows, each keeping indexes that selects windows_size+1 [for (x,t)] elements\n",
- " #from data vector (self.x) that itself stays always sorted w.r.t time\n",
- " range_slices = numpy.zeros((self.batch_size, self.window_size + 1), dtype=numpy.int32)\n",
- " \n",
- " for i in xrange(0, self.batch_size):\n",
- " range_slices[i, :] = \\\n",
- " numpy.arange(range_idx[i], \n",
- " range_idx[i] - self.window_size - 1, \n",
- " -1,\n",
- " dtype=numpy.int32)[::-1]\n",
- "\n",
- " #here we use advanced indexing to select slices from observation vector\n",
- " #last column of rval_x makes our targets t (as we splice window_size + 1\n",
- " tmp_x = self.x[range_slices]\n",
- " rval_x = tmp_x[:,:-1]\n",
- " rval_t = tmp_x[:,-1].reshape(self.batch_size, -1)\n",
- " \n",
- " self._curr_idx += self.batch_size\n",
- "\n",
- " return rval_x, rval_t\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 2",
- "language": "python",
- "name": "python2"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 2
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.9"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/notebooks/00_Introduction.ipynb b/notebooks/01_Introduction.ipynb
similarity index 100%
rename from notebooks/00_Introduction.ipynb
rename to notebooks/01_Introduction.ipynb
diff --git a/notebooks/01_Linear_Models_solution.ipynb b/notebooks/01_Linear_Models_solution.ipynb
deleted file mode 100644
index b5f7a4a..0000000
--- a/notebooks/01_Linear_Models_solution.ipynb
+++ /dev/null
@@ -1,896 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Introduction\n",
- "\n",
- "This tutorial is about linear transforms - a basic building block of neural networks, including deep learning models.\n",
- "\n",
- "# Virtual environments and syncing repositories\n",
- "\n",
- "Before you proceed onwards, remember to activate you virtual environments so you can use the software you installed last week as well as run the notebooks in interactive mode, not through the github.com website.\n",
- "\n",
- "## Virtual environments\n",
- "\n",
- "To activate the virtual environment:\n",
- " * If you were in last week's Tuesday or Wednesday group type `activate_mlp` or `source ~/mlpractical/venv/bin/activate`\n",
- " * If you were in the Monday group:\n",
- " + and if you have chosen the **comfy** way type: `workon mlpractical`\n",
- " + and if you have chosen the **generic** way, `source` your virutal environment using `source` and specyfing the path to the activate script (you need to localise it yourself, there were not any general recommendations w.r.t dir structure and people have installed it in different places, usually somewhere in the home directories. If you cannot easily find it by yourself, use something like: `find . -iname activate` ):\n",
- "\n",
- "## On Synchronising repositories\n",
- "\n",
- "Enter the git mlp repository you set up last week (i.e. `~/mlpractical/repo-mlp`) and once you sync the repository (in one of the two below ways, or look at our short Git FAQ here), start the notebook session by typing:\n",
- "\n",
- "```\n",
- "ipython notebook\n",
- "```\n",
- "\n",
- "### Default way\n",
- "\n",
- "To avoid potential conflicts between the changes you have made since last week and our additions, we recommend `stash` your changes and `pull` the new code from the mlpractical repository by typing:\n",
- "\n",
- "1. `git stash save \"Lab1 work\"`\n",
- "2. `git pull`\n",
- "\n",
- "Then, if you need to, you can always (temporaily) restore a desired state of the repository (look here).\n",
- "\n",
- "**Otherwise** you may also create a branch for each lab separately (again, look here and git tutorials we linked there), this will allow you to keep `master` branch clean, and pull changes into it every week from the central repository. At the same time branching gives you much more flexibility with changes you introduce to the code as potential conflicts will not occur until you try to make an explicit merge.\n",
- "\n",
- "### For advanced github users\n",
- "\n",
- "It is OK if you want to keep your changes and merge the new code with whatever you already have, but you need to know what you are doing and how to resolve conflicts.\n",
- " \n",
- " "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Single Layer Models\n",
- "\n",
- "***\n",
- "### Note on storing matrices in computer memory\n",
- "\n",
- "Consider you want to store the following array in memory: $\\left[ \\begin{array}{ccc}\n",
- "1 & 2 & 3 \\\\\n",
- "4 & 5 & 6 \\\\\n",
- "7 & 8 & 9 \\end{array} \\right]$ \n",
- "\n",
- "In computer memory the above matrix would be organised as a vector in either (assume you allocate the memory at once for the whole matrix):\n",
- "\n",
- "* Row-wise layout where the order would look like: $\\left [ \\begin{array}{ccccccccc}\n",
- "1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\end{array} \\right ]$\n",
- "* Column-wise layout where the order would look like: $\\left [ \\begin{array}{ccccccccc}\n",
- "1 & 4 & 7 & 2 & 5 & 8 & 3 & 6 & 9 \\end{array} \\right ]$\n",
- "\n",
- "Although `numpy` can easily handle both formats (possibly with some computational overhead), in our code we will stick with modern (and default) `c`-like approach and use row-wise format (contrary to Fortran that used column-wise approach). \n",
- "\n",
- "This means, that in this tutorial:\n",
- "* vectors are kept row-wise $\\mathbf{x} = (x_1, x_1, \\ldots, x_D) $ (rather than $\\mathbf{x} = (x_1, x_1, \\ldots, x_D)^T$)\n",
- "* similarly, in case of matrices we will stick to: $\\left[ \\begin{array}{cccc}\n",
- "x_{11} & x_{12} & \\ldots & x_{1D} \\\\\n",
- "x_{21} & x_{22} & \\ldots & x_{2D} \\\\\n",
- "x_{31} & x_{32} & \\ldots & x_{3D} \\\\ \\end{array} \\right]$ and each row (i.e. $\\left[ \\begin{array}{cccc} x_{11} & x_{12} & \\ldots & x_{1D} \\end{array} \\right]$) represents a single data-point (like one MNIST image or one window of observations)\n",
- "\n",
- "In lecture slides you will find the equations following the conventional mathematical column-wise approach, but you can easily map them one way or the other using using matrix transpose.\n",
- "\n",
- "***\n",
- "\n",
- "## Linear and Affine Transforms\n",
- "\n",
- "The basis of all linear models is so called affine transform, that is a transform that implements some linear transformation and translation of input features. The transforms we are going to use are parameterised by:\n",
- "\n",
- " * Weight matrix $\\mathbf{W} \\in \\mathbb{R}^{D\\times K}$: where element $w_{ik}$ is the weight from input $x_i$ to output $y_k$\n",
- " * Bias vector $\\mathbf{b}\\in R^{K}$ : where element $b_{k}$ is the bias for output $k$\n",
- "\n",
- "Note, the bias is simply some additve term, and can be easily incorporated into an additional row in weight matrix and an additinal input in the inputs which is set to $1.0$ (as in the below picture taken from the lecture slides). However, here (and in the code) we will keep them separate.\n",
- "\n",
- "\n",
- "\n",
- "For instance, for the above example of 5-dimensional input vector by $\\mathbf{x} = (x_1, x_2, x_3, x_4, x_5)$, weight matrix $\\mathbf{W}=\\left[ \\begin{array}{ccc}\n",
- "w_{11} & w_{12} & w_{13} \\\\\n",
- "w_{21} & w_{22} & w_{23} \\\\\n",
- "w_{31} & w_{32} & w_{33} \\\\\n",
- "w_{41} & w_{42} & w_{43} \\\\\n",
- "w_{51} & w_{52} & w_{53} \\\\ \\end{array} \\right]$, bias vector $\\mathbf{b} = (b_1, b_2, b_3)$ and outputs $\\mathbf{y} = (y_1, y_2, y_3)$, one can write the transformation as follows:\n",
- "\n",
- "(for the $i$-th output)\n",
- "\n",
- "(1) $\n",
- "\\begin{equation}\n",
- " y_i = b_i + \\sum_j x_jw_{ji}\n",
- "\\end{equation}\n",
- "$\n",
- "\n",
- "or the equivalent vector form (where $\\mathbf w_i$ is the $i$-th column of $\\mathbf W$, but note, when we **slice** the $i$th column we will get a **vector** $\\mathbf w_i = (w_{1i}, w_{2i}, w_{3i}, w_{4i}, w_{5i})$, hence the transpose for $\\mathbf w_i$ in the below equation):\n",
- "\n",
- "(2) $\n",
- "\\begin{equation}\n",
- " y_i = b_i + \\mathbf x \\mathbf w_i^T\n",
- "\\end{equation}\n",
- "$\n",
- "\n",
- "The same operation can be also written in matrix form, to compute all the outputs $\\mathbf{y}$ at the same time:\n",
- "\n",
- "(3) $\n",
- "\\begin{equation}\n",
- " \\mathbf y=\\mathbf x\\mathbf W + \\mathbf b\n",
- "\\end{equation}\n",
- "$\n",
- "\n",
- "This is equivalent to slides 12/13 in lecture 1, except we are using row vectors.\n",
- "\n",
- "When $\\mathbf{x}$ is a mini-batch (contains $B$ data-points of dimension $D$ each), i.e. $\\left[ \\begin{array}{cccc}\n",
- "x_{11} & x_{12} & \\ldots & x_{1D} \\\\\n",
- "x_{21} & x_{22} & \\ldots & x_{2D} \\\\\n",
- "\\cdots \\\\\n",
- "x_{B1} & x_{B2} & \\ldots & x_{BD} \\\\ \\end{array} \\right]$ equation (3) effectively becomes to be\n",
- "\n",
- "(4) $\n",
- "\\begin{equation}\n",
- " \\mathbf Y=\\mathbf X\\mathbf W + \\mathbf b\n",
- "\\end{equation}\n",
- "$\n",
- "\n",
- "where $\\mathbf{W} \\in \\mathbb{R}^{D\\times K}$ and both $\\mathbf{X}\\in\\mathbb{R}^{B\\times D}$ and $\\mathbf{Y}\\in\\mathbb{R}^{B\\times K}$ are matrices, and $\\mathbf{b}\\in\\mathbb{R}^{1\\times K}$ needs to be broadcasted $B$ times (numpy will do this by default). However, we will not make an explicit distinction between a special case for $B=1$ and $B>1$ and simply use equation (3) instead, although $\\mathbf{x}$ and hence $\\mathbf{y}$ could be matrices. From an implementation point of view, it does not matter.\n",
- "\n",
- "The desired functionality for matrix multiplication in numpy is provided by numpy.dot function. If you haven't use it so far, get familiar with it as we will use it extensively."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### A general note on random number generators\n",
- "\n",
- "It is generally a good practice (for machine learning applications **not** for cryptography!) to seed a pseudo-random number generator once at the beginning of the experiment, and use it later through the code where necesarry. This makes it easier to reproduce results since random initialisations can be replicated. As such, within this course we are going use a single random generator object, similar to the below:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "import numpy\n",
- "import sys\n",
- "\n",
- "#initialise the random generator to be used later\n",
- "seed=[2015, 10, 1]\n",
- "random_generator = numpy.random.RandomState(seed)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Exercise 1 \n",
- "\n",
- "Using `numpy.dot`, implement **forward** propagation through the linear transform defined by equations (3) and (4) for $B=1$ and $B>1$ i.e. use parameters $\\mathbf{W}$ and $\\mathbf{b}$ with data $\\mathbf{X}$ to determine $\\mathbf{Y}$. Use `MNISTDataProvider` (introduced last week) to generate $\\mathbf{X}$. We are going to write a function for each equation:\n",
- "1. `y1_equation_1`: Return the value of the $1^{st}$ dimension of $\\mathbf{y}$ (the output of the first output node) given a single training data point $\\mathbf{x}$ using a sum\n",
- "1. `y1_equation_2`: Repeat above using vector multiplication (use `numpy.dot()`)\n",
- "1. `y_equation_3`: Return the value of $\\mathbf{y}$ (the whole output layer) given a single training data point $\\mathbf{x}$\n",
- "1. `Y_equation_4`: Return the value of $\\mathbf{Y}$ given $\\mathbf{X}$\n",
- "\n",
- "We have initialised $\\mathbf{b}$ to zeros and randomly generated $\\mathbf{W}$ for you. The constants introduced above are:\n",
- "* The number of data points $B = 3$\n",
- "* The dimensionality of the input $D = 10$\n",
- "* The dimensionality of the output $K = 10$"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "from mlp.dataset import MNISTDataProvider\n",
- "\n",
- "mnist_dp = MNISTDataProvider(dset='valid', batch_size=3, max_num_batches=1, randomize=False)\n",
- "B = 3\n",
- "D = 784\n",
- "K = 10\n",
- "irange = 0.1\n",
- "W = random_generator.uniform(-irange, irange, (D, K)) \n",
- "b = numpy.zeros((10,))\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "y1e1 0.55861474982\n",
- "y1e2 0.55861474982\n",
- "ye3 [ 0.55861475 0.79450077 0.17439693 0.00265688 0.66272539 -0.09985686\n",
- " 0.56468591 0.58105588 -0.18613727 0.08151257]\n",
- "Ye4 [[ 0.55861475 0.79450077 0.17439693 0.00265688 0.66272539 -0.09985686\n",
- " 0.56468591 0.58105588 -0.18613727 0.08151257]\n",
- " [-0.43965864 0.59573972 -0.22691119 0.26767124 -0.31343979 0.07224664\n",
- " -0.19616183 0.0851733 -0.24088286 -0.19305162]\n",
- " [-0.20176359 0.42394166 -1.03984446 0.15492101 0.15694745 -0.53741022\n",
- " 0.05887668 -0.21124527 -0.07870156 -0.00506471]]\n"
- ]
- }
- ],
- "source": [
- "mnist_dp.reset()\n",
- "\n",
- "#implement following functions, then run the cell\n",
- "def y1_equation_1(x, W, b):\n",
- " k = 0\n",
- " s = 0\n",
- " for j in xrange(len(x)):\n",
- " s += x[j] * W[j,k]\n",
- " return b[k] + s\n",
- " \n",
- "def y1_equation_2(x, W, b):\n",
- " k = 0\n",
- " return numpy.dot(x, W[:,k]) + b[k]\n",
- "\n",
- "def y_equation_3(x, W, b):\n",
- " return numpy.dot(x, W) + b\n",
- "\n",
- "def y_equation_4(x, W, b):\n",
- " return numpy.dot(x, W) + b\n",
- "\n",
- "for X, t in mnist_dp:\n",
- " n = 0\n",
- " y1e1 = y1_equation_1(X[n], W, b)\n",
- " y1e2 = y1_equation_2(X[n], W, b)\n",
- " ye3 = y_equation_3(X[n], W, b)\n",
- " Ye4 = y_equation_4(X, W, b)\n",
- "\n",
- "print 'y1e1', y1e1\n",
- "print 'y1e2', y1e2\n",
- "print 'ye3', ye3\n",
- "print 'Ye4', Ye4"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "collapsed": true
- },
- "source": [
- "## Exercise 2\n",
- "\n",
- "Modify (if necessary) examples from Exercise 1 to perform **backward** propagation, that is, given $\\mathbf{y}$ (obtained in previous step) and weight matrix $\\mathbf{W}$, project $\\mathbf{y}$ onto the input space $\\mathbf{x}$ (ignore or set to zero the biases towards $\\mathbf{x}$ in backward pass). Mathematically, we are interested in the following transformation: $\\mathbf{z}=\\mathbf{y}\\mathbf{W}^T$"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[[-0.00683757 -0.13638553 0.00203203 ..., 0.02690207 -0.07364245\n",
- " 0.04403087]\n",
- " [-0.00447621 -0.06409652 0.01211384 ..., 0.0402248 -0.04490571\n",
- " -0.05013801]\n",
- " [ 0.03981022 -0.13705957 0.05882239 ..., 0.04491902 -0.08644539\n",
- " -0.07106441]]\n"
- ]
- }
- ],
- "source": [
- "y = y_equation_3(x, W, b)\n",
- "z = numpy.dot(y, W.T)\n",
- "\n",
- "print z\n",
- "assert z.shape == x.shape"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "***\n",
- "## Exercise 3 (optional)\n",
- "\n",
- "In case you do not fully understand how matrix-vector and/or matrix-matrix products work, consider implementing `my_dot_mat_mat` function (you have been given `my_dot_vec_mat` code to look at as an example) which takes as the input the following arguments:\n",
- "\n",
- "* D-dimensional input vector $\\mathbf{x} = (x_1, x_2, \\ldots, x_D) $.\n",
- "* Weight matrix $\\mathbf{W}\\in\\mathbb{R}^{D\\times K}$:\n",
- "\n",
- "and returns:\n",
- "\n",
- "* K-dimensional output vector $\\mathbf{y} = (y_1, \\ldots, y_K) $\n",
- "\n",
- "Your job is to write a variant that works in a mini-batch mode where both $\\mathbf{x}\\in\\mathbb{R}^{B\\times D}$ and $\\mathbf{y}\\in\\mathbb{R}^{B\\times K}$ are matrices in which each rows contain one of $B$ data-points from mini-batch (rather than $\\mathbf{x}\\in\\mathbb{R}^{D}$ and $\\mathbf{y}\\in\\mathbb{R}^{K}$)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "def my_dot_vec_mat(x, W):\n",
- " J = x.shape[0]\n",
- " K = W.shape[1]\n",
- " assert (J == W.shape[0]), (\n",
- " \"Number of columns of x expected to \"\n",
- " \" to be equal to the number of rows in \"\n",
- " \"W, bot got shapes %s, %s\" % (x.shape, W.shape)\n",
- " )\n",
- " y = numpy.zeros((K,))\n",
- " for k in xrange(0, K):\n",
- " for j in xrange(0, J):\n",
- " y[k] += x[j] * W[j,k]\n",
- " \n",
- " return y"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Well done!\n"
- ]
- }
- ],
- "source": [
- "irange = 0.1 #+-range from which we draw the random numbers\n",
- "\n",
- "x = random_generator.uniform(-irange, irange, (5,)) \n",
- "W = random_generator.uniform(-irange, irange, (5,3)) \n",
- "\n",
- "y_my = my_dot_vec_mat(x, W)\n",
- "y_np = numpy.dot(x, W)\n",
- "\n",
- "same = numpy.allclose(y_my, y_np)\n",
- "\n",
- "if same:\n",
- " print 'Well done!'\n",
- "else:\n",
- " print 'Matrices are different:'\n",
- " print 'y_my is: ', y_my\n",
- " print 'y_np is: ', y_np"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "def my_dot_mat_mat(x, W):\n",
- " I = x.shape[0]\n",
- " J = x.shape[1]\n",
- " K = W.shape[1]\n",
- " assert (J == W.shape[0]), (\n",
- " \"Number of columns in of x expected to \"\n",
- " \" to be the same as rows in W, got\"\n",
- " )\n",
- " #allocate the output container\n",
- " y = numpy.zeros((I, K))\n",
- " \n",
- " #implement here matrix-matrix inner product here\n",
- " for i in xrange(0, I):\n",
- " for k in xrange(0, K):\n",
- " for j in xrange(0, J):\n",
- " y[i, k] += x[i, j] * W[j,k]\n",
- " \n",
- " return y"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Test whether you get comparable numbers to what numpy is producing:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Well done!\n"
- ]
- }
- ],
- "source": [
- "irange = 0.1 #+-range from which we draw the random numbers\n",
- "\n",
- "x = random_generator.uniform(-irange, irange, (2,5)) \n",
- "W = random_generator.uniform(-irange, irange, (5,3)) \n",
- "\n",
- "y_my = my_dot_mat_mat(x, W)\n",
- "y_np = numpy.dot(x, W)\n",
- "\n",
- "same = numpy.allclose(y_my, y_np)\n",
- "\n",
- "if same:\n",
- " print 'Well done!'\n",
- "else:\n",
- " print 'Matrices are different:'\n",
- " print 'y_my is: ', y_my\n",
- " print 'y_np is: ', y_np"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Now we benchmark each approach (we do it in separate cells, as timeit currently can measure whole cell execuiton only)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "#generate bit bigger matrices, to better evaluate timings\n",
- "x = random_generator.uniform(-irange, irange, (10, 1000))\n",
- "W = random_generator.uniform(-irange, irange, (1000, 100))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "my_dot timings:\n",
- "10 loops, best of 3: 726 ms per loop\n"
- ]
- }
- ],
- "source": [
- "print 'my_dot timings:'\n",
- "%timeit -n10 my_dot_mat_mat(x, W)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "numpy.dot timings:\n",
- "10 loops, best of 3: 1.17 ms per loop\n"
- ]
- }
- ],
- "source": [
- "print 'numpy.dot timings:'\n",
- "%timeit -n10 numpy.dot(x, W)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "**Optional section ends here**\n",
- "***"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Iterative learning of linear models\n",
- "\n",
- "We will learn the model with stochastic gradient descent on N data-points using mean square error (MSE) loss function, which is defined as follows:\n",
- "\n",
- "(5) $\n",
- "E = \\frac{1}{2} \\sum_{n=1}^N ||\\mathbf{y}^n - \\mathbf{t}^n||^2 = \\sum_{n=1}^N E^n \\\\\n",
- " E^n = \\frac{1}{2} ||\\mathbf{y}^n - \\mathbf{t}^n||^2\n",
- "$\n",
- "\n",
- "(6) $ E^n = \\frac{1}{2} \\sum_{k=1}^K (y_k^n - t_k^n)^2 $\n",
- " \n",
- "Hence, the gradient w.r.t (with respect to) the $r$ output y of the model is defined as, so called delta function, $\\delta_r$: \n",
- "\n",
- "(8) $\\frac{\\partial{E^n}}{\\partial{y_{r}}} = (y^n_r - t^n_r) = \\delta^n_r \\quad ; \\quad\n",
- " \\delta^n_r = y^n_r - t^n_r \\\\\n",
- " \\frac{\\partial{E}}{\\partial{y_{r}}} = \\sum_{n=1}^N \\frac{\\partial{E^n}}{\\partial{y_{r}}} = \\sum_{n=1}^N \\delta^n_r\n",
- "$\n",
- "\n",
- "Similarly, using the above $\\delta^n_r$ one can express the gradient of the weight $w_{sr}$ (from the s-th input to the r-th output) for linear model and MSE cost as follows:\n",
- "\n",
- "(9) $\n",
- " \\frac{\\partial{E^n}}{\\partial{w_{sr}}} = (y^n_r - t^n_r)x_s^n = \\delta^n_r x_s^n \\quad\\\\\n",
- " \\frac{\\partial{E}}{\\partial{w_{sr}}} = \\sum_{n=1}^N \\frac{\\partial{E^n}}{\\partial{w_{rs}}} = \\sum_{n=1}^N \\delta^n_r x_s^n\n",
- "$\n",
- "\n",
- "and the gradient for bias parameter at the $r$-th output is:\n",
- "\n",
- "(10) $\n",
- " \\frac{\\partial{E}}{\\partial{b_{r}}} = \\sum_{n=1}^N \\frac{\\partial{E^n}}{\\partial{b_{r}}} = \\sum_{n=1}^N \\delta^n_r\n",
- "$"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "\n",
- " \n",
- " * Input vector $\\mathbf{x} = (x_1, x_2, \\ldots, x_D) $\n",
- " * Output scalar $y_1$\n",
- " * Weight matrix $\\mathbf{W}$: $w_{ik}$ is the weight from input $x_i$ to output $y_k$. Note, here this is really a vector since a single scalar output, y_1.\n",
- " * Scalar bias $b$ for the only output in our model \n",
- " * Scalar target $t$ for the only output in out model\n",
- " \n",
- "First, ensure you can make use of data provider (note, for training data has been normalised to zero mean and unit variance, hence different effective range than one can find in file):"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Observations: [[-0.12 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13]\n",
- " [-0.11 -0.1 0.09 -0.06 -0.09 -0. 0.28 -0.12 -0.12 -0.08]\n",
- " [-0.13 0.05 -0.13 -0.01 -0.11 -0.13 -0.13 -0.13 -0.13 -0.13]\n",
- " [ 0.2 0.12 0.25 0.16 0.03 -0. 0.15 0.08 -0.08 -0.11]\n",
- " [-0.13 -0.12 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13]\n",
- " [-0.1 0.51 1.52 0.14 -0.02 0.77 0.11 0.79 -0.02 0.08]\n",
- " [ 0.24 0.15 -0.01 0.08 -0.1 0.45 -0.12 -0.1 -0.13 0.48]\n",
- " [ 0.13 -0.06 -0.07 -0.11 -0.11 -0.11 -0.13 -0.11 -0.02 -0.12]\n",
- " [-0.06 0.28 -0.13 0.06 0.09 0.09 0.01 -0.07 0.14 -0.11]\n",
- " [-0.13 -0.13 -0.1 -0.06 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13]]\n",
- "To predict: [[-0.12]\n",
- " [-0.12]\n",
- " [-0.13]\n",
- " [-0.1 ]\n",
- " [-0.13]\n",
- " [-0.08]\n",
- " [ 0.24]\n",
- " [-0.13]\n",
- " [-0.02]\n",
- " [-0.13]]\n",
- "Observations: [[-0.09 -0.13 -0.13 -0.03 -0.05 -0.11 -0.13 -0.13 -0.13 -0.13]\n",
- " [-0.03 0.32 0.28 0.09 -0.04 0.19 0.31 -0.13 0.37 0.34]\n",
- " [ 0.12 0.13 0.06 -0.1 -0.1 0.94 0.24 0.12 0.28 -0.04]\n",
- " [ 0.26 0.17 -0.04 -0.13 -0.12 -0.09 -0.12 -0.13 -0.1 -0.13]\n",
- " [-0.1 -0.1 -0.01 -0.03 -0.07 0.05 -0.03 -0.12 -0.05 -0.13]\n",
- " [-0.13 -0.13 -0.13 -0.13 -0.13 -0.13 0.1 -0.13 -0.13 -0.13]\n",
- " [-0.01 -0.1 -0.13 -0.13 -0.12 -0.13 -0.13 -0.13 -0.13 -0.11]\n",
- " [-0.11 -0.06 -0.11 0.02 -0.03 -0.02 -0.05 -0.11 -0.13 -0.13]\n",
- " [-0.01 0.25 -0.08 0.04 -0.1 -0.12 0.06 -0.1 0.08 -0.06]\n",
- " [-0.09 -0.09 -0.09 -0.13 -0.11 -0.12 -0. -0.02 0.19 -0.11]]\n",
- "To predict: [[-0.13]\n",
- " [-0.11]\n",
- " [-0.09]\n",
- " [-0.08]\n",
- " [ 0.19]\n",
- " [-0.13]\n",
- " [-0.13]\n",
- " [-0.03]\n",
- " [-0.13]\n",
- " [-0.11]]\n",
- "Observations: [[-0.08 -0.11 -0.11 0.32 0.05 -0.11 -0.13 0.07 0.08 0.63]\n",
- " [-0.07 -0.1 -0.09 -0.08 0.26 -0.05 -0.1 -0. 0.36 -0.12]\n",
- " [-0.03 -0.1 0.19 -0.02 0.35 0.38 -0.1 0.44 -0.02 0.21]\n",
- " [-0.12 -0. -0.02 0.19 -0.11 -0.11 -0.13 -0.11 -0.02 -0.13]\n",
- " [ 0.09 0.1 -0.03 -0.05 0. -0.12 -0.12 -0.13 -0.13 -0.13]\n",
- " [ 0.21 0.05 -0.12 -0.05 -0.08 -0.1 -0.13 -0.13 -0.13 -0.13]\n",
- " [-0.04 -0.11 0.19 0.16 -0.01 -0.07 -0. -0.06 -0.03 0.16]\n",
- " [ 0.09 0.05 0.51 0.34 0.16 0.51 0.56 0.21 -0.06 -0. ]\n",
- " [-0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.09 0.49]\n",
- " [-0.06 -0.11 -0.13 0.06 -0.01 -0.12 0.54 0.2 -0.1 -0.11]]\n",
- "To predict: [[ 0.1 ]\n",
- " [ 0.09]\n",
- " [ 0.16]\n",
- " [-0.13]\n",
- " [-0.13]\n",
- " [ 0.04]\n",
- " [-0.1 ]\n",
- " [ 0.05]\n",
- " [-0.1 ]\n",
- " [-0.11]]\n"
- ]
- }
- ],
- "source": [
- "from mlp.dataset import MetOfficeDataProvider\n",
- "\n",
- "modp = MetOfficeDataProvider(10, batch_size=10, max_num_batches=3, randomize=True)\n",
- "\n",
- "%precision 2\n",
- "for x, t in modp:\n",
- " print 'Observations: ', x\n",
- " print 'To predict: ', t"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Exercise 4\n",
- "\n",
- "The below code implements a very simple variant of stochastic gradient descent for the weather regression example. Your task is to implement 5 functions in the next cell and then run two next cells that 1) build sgd functions and 2) run the actual training."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 16,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "\n",
- "#When implementing those, take into account the mini-batch case, for which one is\n",
- "#expected to sum the errors for each example\n",
- "\n",
- "def fprop(x, W, b):\n",
- " #code implementing eq. (3)\n",
- " return numpy.dot(x, W) + b\n",
- "\n",
- "def cost(y, t):\n",
- " #Mean Square Error cost, equation (5)\n",
- " return numpy.mean(0.5*numpy.sum((y - t)**2, axis=1))\n",
- "\n",
- "def cost_grad(y, t):\n",
- " #Gradient of the cost w.r.t y equation (8)\n",
- " return y - t\n",
- "\n",
- "def cost_wrt_W(cost_grad, x):\n",
- " #Gradient of the cost w.r.t W, equation (9)\n",
- " return numpy.dot(x.T, cost_grad)\n",
- " \n",
- "def cost_wrt_b(cost_grad):\n",
- " #Gradient of the cost w.r.t to b, equation (10)\n",
- " return numpy.sum(cost_grad, axis = 0)\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 17,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "\n",
- "def sgd_epoch(data_provider, W, b, learning_rate):\n",
- " mse_stats = []\n",
- " \n",
- " #get the minibatch of data\n",
- " for x, t in data_provider:\n",
- "\n",
- " #1. get the estimate of y\n",
- " y = fprop(x, W, b)\n",
- "\n",
- " #2. compute the loss function\n",
- " tmp = cost(y, t)\n",
- " mse_stats.append(tmp)\n",
- " \n",
- " #3. compute the grad of the cost w.r.t the output layer activation y\n",
- " #i.e. how the cost changes when output y changes\n",
- " cost_grad_deltas = cost_grad(y, t)\n",
- "\n",
- " #4. compute the gradients w.r.t model's parameters\n",
- " grad_W = cost_wrt_W(cost_grad_deltas, x)\n",
- " grad_b = cost_wrt_b(cost_grad_deltas)\n",
- "\n",
- " #4. Update the model, we update with the mean gradient\n",
- " # over the minibatch, rather than sum of particular gradients\n",
- " # in a minibatch, to do so we scale the learning rate by batch_size\n",
- " batch_size = x.shape[0]\n",
- " effect_learn_rate = learning_rate / batch_size\n",
- "\n",
- " W = W - effect_learn_rate * grad_W\n",
- " b = b - effect_learn_rate * grad_b\n",
- " \n",
- " return W, b, numpy.mean(mse_stats)\n",
- "\n",
- "def sgd(data_provider, W, b, learning_rate=0.1, max_epochs=10):\n",
- " \n",
- " for epoch in xrange(0, max_epochs):\n",
- " #reset the data provider\n",
- " data_provider.reset()\n",
- " \n",
- " #train for one epoch\n",
- " W, b, mean_cost = \\\n",
- " sgd_epoch(data_provider, W, b, learning_rate)\n",
- " \n",
- " print \"MSE training cost after %d-th epoch is %f\" % (epoch + 1, mean_cost)\n",
- " \n",
- " return W, b\n",
- " \n",
- " "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 18,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "MSE training cost after 1-th epoch is 0.017213\n",
- "MSE training cost after 2-th epoch is 0.016103\n",
- "MSE training cost after 3-th epoch is 0.015705\n",
- "MSE training cost after 4-th epoch is 0.015437\n",
- "MSE training cost after 5-th epoch is 0.015255\n",
- "MSE training cost after 6-th epoch is 0.015128\n",
- "MSE training cost after 7-th epoch is 0.015041\n",
- "MSE training cost after 8-th epoch is 0.014981\n",
- "MSE training cost after 9-th epoch is 0.014936\n",
- "MSE training cost after 10-th epoch is 0.014903\n",
- "MSE training cost after 11-th epoch is 0.014879\n",
- "MSE training cost after 12-th epoch is 0.014862\n",
- "MSE training cost after 13-th epoch is 0.014849\n",
- "MSE training cost after 14-th epoch is 0.014839\n",
- "MSE training cost after 15-th epoch is 0.014830\n",
- "MSE training cost after 16-th epoch is 0.014825\n",
- "MSE training cost after 17-th epoch is 0.014820\n",
- "MSE training cost after 18-th epoch is 0.014813\n",
- "MSE training cost after 19-th epoch is 0.014813\n",
- "MSE training cost after 20-th epoch is 0.014810\n",
- "MSE training cost after 21-th epoch is 0.014808\n",
- "MSE training cost after 22-th epoch is 0.014805\n",
- "MSE training cost after 23-th epoch is 0.014806\n",
- "MSE training cost after 24-th epoch is 0.014804\n",
- "MSE training cost after 25-th epoch is 0.014796\n",
- "MSE training cost after 26-th epoch is 0.014798\n",
- "MSE training cost after 27-th epoch is 0.014801\n",
- "MSE training cost after 28-th epoch is 0.014802\n",
- "MSE training cost after 29-th epoch is 0.014801\n",
- "MSE training cost after 30-th epoch is 0.014799\n",
- "MSE training cost after 31-th epoch is 0.014799\n",
- "MSE training cost after 32-th epoch is 0.014793\n",
- "MSE training cost after 33-th epoch is 0.014800\n",
- "MSE training cost after 34-th epoch is 0.014796\n",
- "MSE training cost after 35-th epoch is 0.014799\n",
- "MSE training cost after 36-th epoch is 0.014800\n",
- "MSE training cost after 37-th epoch is 0.014798\n",
- "MSE training cost after 38-th epoch is 0.014799\n",
- "MSE training cost after 39-th epoch is 0.014799\n",
- "MSE training cost after 40-th epoch is 0.014794\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "(array([[ 0.01],\n",
- " [ 0.03],\n",
- " [ 0.03],\n",
- " [ 0.04],\n",
- " [ 0.06],\n",
- " [ 0.07],\n",
- " [ 0.26]]), array([-0.]))"
- ]
- },
- "execution_count": 18,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "\n",
- "#some hyper-parameters\n",
- "window_size = 7\n",
- "irange = 0.1\n",
- "learning_rate = 0.001\n",
- "max_epochs=40\n",
- "\n",
- "# note, while developing you can set max_num_batches to some positive number to limit\n",
- "# the number of training data-points (you will get feedback faster)\n",
- "mdp = MetOfficeDataProvider(window_size, batch_size=10, max_num_batches=-100, randomize=True)\n",
- "\n",
- "#initialise the parameters\n",
- "W = random_generator.uniform(-irange, irange, (window_size, 1))\n",
- "b = random_generator.uniform(-irange, irange, (1, ))\n",
- "\n",
- "#train the model\n",
- "sgd(mdp, W, b, learning_rate=learning_rate, max_epochs=max_epochs)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "collapsed": true
- },
- "source": [
- "## Exercise 5\n",
- "\n",
- "Modify the above regression problem so the model makes binary classification whether the the weather is going to be one of those \\{rainy, sunny} (look at slide 12 of the 2nd lecture)\n",
- "\n",
- "Tip: You need to introduce the following changes:\n",
- "1. Modify `MetOfficeDataProvider` (for example, inherit from MetOfficeDataProvider to create a new class MetOfficeDataProviderBin) and modify `next()` function so it returns as `targets` either 0 (sunny - if the the amount of rain [before mean/variance normalisation] is equal to 0 or 1 (rainy -- otherwise).\n",
- "2. Modify the functions from previous exercise so the fprop implements `sigmoid` on top of affine transform.\n",
- "3. Modify cost function to binary cross-entropy\n",
- "4. Make sure you compute the gradients correctly (as you have changed both the output and the cost)\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "#sorry, this one will be added later..."
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 2",
- "language": "python",
- "name": "python2"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 2
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.10"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/notebooks/01_Linear_Models.ipynb b/notebooks/02_Linear_models.ipynb
similarity index 100%
rename from notebooks/01_Linear_Models.ipynb
rename to notebooks/02_Linear_models.ipynb
diff --git a/notebooks/02_MNIST_SLN_solution.ipynb b/notebooks/02_MNIST_SLN_solution.ipynb
deleted file mode 100644
index 1538366..0000000
--- a/notebooks/02_MNIST_SLN_solution.ipynb
+++ /dev/null
@@ -1,341 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Introduction\n",
- "\n",
- "This tutorial is an introduction to the first coursework about multi-layer networks (also known as Multi-Layer Perceptrons - MLPs - or Deep Neural Networks - DNNs). Here, we will show how to build a single layer linear model (similar to the one from the previous lab) for MNIST digit classification using the provided code-base. \n",
- "\n",
- "The principal purpose of this introduction is to get you familiar with how to connect the code blocks (and what operations each of them implements) in order to set up an experiment that includes 1) building the model structure 2) optimising the model's parameters (weights) and 3) evaluating the model on test data. \n",
- "\n",
- "## For those affected by notebook kernel issues\n",
- "\n",
- "In case you are still having issues with running notebook kernels, have a look at [this note](https://github.com/CSTR-Edinburgh/mlpractical/blob/master/kernel_issue_fix.md) on the GitHub.\n",
- "\n",
- "## Virtual environments\n",
- "\n",
- "Before you proceed onwards, remember to activate your virtual environment:\n",
- " * If you were in last week's Tuesday or Wednesday group type `activate_mlp` or `source ~/mlpractical/venv/bin/activate`\n",
- " * If you were in the Monday group:\n",
- " + and if you have chosen the **comfy** way type: `workon mlpractical`\n",
- " + and if you have chosen the **generic** way, `source` your virutal environment using `source` and specyfing the path to the activate script (you need to localise it yourself, there were not any general recommendations w.r.t dir structure and people have installed it in different places, usually somewhere in the home directories. If you cannot easily find it by yourself, use something like: `find . -iname activate` ):\n",
- "\n",
- "## Syncing the git repository\n",
- "\n",
- "Look here for more details. But in short, we recommend to create a separate branch for the coursework, as follows:\n",
- "\n",
- "1. Enter the mlpractical directory `cd ~/mlpractical/repo-mlp`\n",
- "2. List the branches and check which is currently active by typing: `git checkout`\n",
- "3. If you are not in `master` branch, switch to it by typing: \n",
- "```\n",
- "git checkout master\n",
- " ```\n",
- "4. Then update the repository (note, assuming master does not have any conflicts), if there are some, have a look here\n",
- "```\n",
- "git pull\n",
- "```\n",
- "5. And now, create the new branch & swith to it by typing:\n",
- "```\n",
- "git checkout -b coursework1\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Multi Layer Models\n",
- "\n",
- "Today, we shall build models which can have an arbitrary number of hidden layers. Please have a look at the diagram below, and the corresponding computations (which have an *exact* matrix form as expected by numpy, and row-wise orientation; note that $\\circ$ denotes an element-wise product). In the diagram, we briefly describe how each comptation relates to the code we have provided.\n",
- "\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "1. Structuring the model\n",
- " * The model (for now) is allowed to have a sequence of layers, mapping inputs $\\mathbf{x}$ to outputs $\\mathbf{y}$. \n",
- " * This operation is implemented as a special type of a layer in `mlp.layers.MLP` class. It keeps a sequence of other layers (of various typyes like Linear, Sigmoid, Softmax, etc.) as well as the internal state of a model for a mini-batch, that is, the intermediate data produced in *forward* and *backward* passes.\n",
- "2. Forward computation\n",
- " * `mlp.layers.MLP` provides an `fprop()` method that iterates over defined layers propagates $\\mathbf{x}$ to $\\mathbf{y}$. \n",
- " * Each layer (look at `mlp.layers.Linear` attached below) also implements an `fprop()` method, which performs an atomic, for the given layer, operation. Most often, for the $i$-th layer, we want to obtain a linear transform $\\mathbf a^i$ of the inputs, and apply some non-linear transfer function $f^i(\\mathbf a^i)$ to produce the output $\\mathbf h^i$. Note, in general each layer may implement different activation functions $f^i()$, however for now we will use only `sigmoid` and `softmax`\n",
- "3. Backward computation\n",
- " * Similarly, `mlp.layers.MLP` also implements a `bprop()` function, to back-propagate the errors from the top to the bottom layer. This class also keeps the back-propagated statistics ($\\delta$) to be used later when computing the gradients with respect to the parameters.\n",
- " * This functionality is also re-implemented by particular layers (again, have a look at the `bprop` function of `mlp.layers.Linear`). `bprop()` returns both $\\delta$ (needed to update the parameters) but also back-progapates the gradient down to the inputs. Also note, that depending on whether the layer is the top or not (i.e. if it deals directly with the cost function or not) some simplifications may apply ( as with cross-entropy and softmax). That's why when implementing a new type of layer that may be used as an output layer one also need to specify the implementation of `bprop_cost()`.\n",
- "4. Learning the model\n",
- " * The actual evaluation of the cost as well as the *forward* and *backward* passes may be found in the `train_epoch()` method of `mlp.optimisers.SGDOptimiser`\n",
- " * This function also calls the `pgrads()` method on each layer, that given activations and deltas, returns the list of the gradients of the cost with respect to the model parameters, i.e. $\\frac{\\partial{\\mathbf{E}}}{\\partial{\\mathbf{W^i}}}$ and $\\frac{\\partial{\\mathbf{E}}}{\\partial{\\mathbf{b}^i}}$ at the above diagram (look at an example implementation in `mlp.layers.Linear`)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "# %load -s Linear mlp/layers.py\n",
- "# DO NOT RUN THIS CELL (AS YOU WILL GET ERRORS), IT WAS JUST LOADED TO VISUALISE ABOVE COMMENTS\n",
- "class Linear(Layer):\n",
- "\n",
- " def __init__(self, idim, odim,\n",
- " rng=None,\n",
- " irange=0.1):\n",
- "\n",
- " super(Linear, self).__init__(rng=rng)\n",
- "\n",
- " self.idim = idim\n",
- " self.odim = odim\n",
- "\n",
- " self.W = self.rng.uniform(\n",
- " -irange, irange,\n",
- " (self.idim, self.odim))\n",
- "\n",
- " self.b = numpy.zeros((self.odim,), dtype=numpy.float32)\n",
- "\n",
- " def fprop(self, inputs):\n",
- " \"\"\"\n",
- " Implements a forward propagation through the i-th layer, that is\n",
- " some form of:\n",
- " a^i = xW^i + b^i\n",
- " h^i = f^i(a^i)\n",
- " with f^i, W^i, b^i denoting a non-linearity, weight matrix and\n",
- " biases of this (i-th) layer, respectively and x denoting inputs.\n",
- "\n",
- " :param inputs: matrix of features (x) or the output of the previous layer h^{i-1}\n",
- " :return: h^i, matrix of transformed by layer features\n",
- " \"\"\"\n",
- " a = numpy.dot(inputs, self.W) + self.b\n",
- " # here f() is an identity function, so just return a linear transformation\n",
- " return a\n",
- "\n",
- " def bprop(self, h, igrads):\n",
- " \"\"\"\n",
- " Implements a backward propagation through the layer, that is, given\n",
- " h^i denotes the output of the layer and x^i the input, we compute:\n",
- " dh^i/dx^i which by chain rule is dh^i/da^i da^i/dx^i\n",
- " x^i could be either features (x) or the output of the lower layer h^{i-1}\n",
- " :param h: it's an activation produced in forward pass\n",
- " :param igrads, error signal (or gradient) flowing to the layer, note,\n",
- " this in general case does not corresponds to 'deltas' used to update\n",
- " the layer's parameters, to get deltas ones need to multiply it with\n",
- " the dh^i/da^i derivative\n",
- " :return: a tuple (deltas, ograds) where:\n",
- " deltas = igrads * dh^i/da^i\n",
- " ograds = deltas \\times da^i/dx^i\n",
- " \"\"\"\n",
- "\n",
- " # since df^i/da^i = 1 (f is assumed identity function),\n",
- " # deltas are in fact the same as igrads\n",
- " ograds = numpy.dot(igrads, self.W.T)\n",
- " return igrads, ograds\n",
- "\n",
- " def bprop_cost(self, h, igrads, cost):\n",
- " \"\"\"\n",
- " Implements a backward propagation in case the layer directly\n",
- " deals with the optimised cost (i.e. the top layer)\n",
- " By default, method should implement a bprop for default cost, that is\n",
- " the one that is natural to the layer's output, i.e.:\n",
- " here we implement linear -> mse scenario\n",
- " :param h: it's an activation produced in forward pass\n",
- " :param igrads, error signal (or gradient) flowing to the layer, note,\n",
- " this in general case does not corresponds to 'deltas' used to update\n",
- " the layer's parameters, to get deltas ones need to multiply it with\n",
- " the dh^i/da^i derivative\n",
- " :param cost, mlp.costs.Cost instance defining the used cost\n",
- " :return: a tuple (deltas, ograds) where:\n",
- " deltas = igrads * dh^i/da^i\n",
- " ograds = deltas \\times da^i/dx^i\n",
- " \"\"\"\n",
- "\n",
- " if cost is None or cost.get_name() == 'mse':\n",
- " # for linear layer and mean square error cost,\n",
- " # cost back-prop is the same as standard back-prop\n",
- " return self.bprop(h, igrads)\n",
- " else:\n",
- " raise NotImplementedError('Linear.bprop_cost method not implemented '\n",
- " 'for the %s cost' % cost.get_name())\n",
- "\n",
- " def pgrads(self, inputs, deltas):\n",
- " \"\"\"\n",
- " Return gradients w.r.t parameters\n",
- "\n",
- " :param inputs, input to the i-th layer\n",
- " :param deltas, deltas computed in bprop stage up to -ith layer\n",
- " :return list of grads w.r.t parameters dE/dW and dE/db in *exactly*\n",
- " the same order as the params are returned by get_params()\n",
- "\n",
- " Note: deltas here contain the whole chain rule leading\n",
- " from the cost up to the the i-th layer, i.e.\n",
- " dE/dy^L dy^L/da^L da^L/dh^{L-1} dh^{L-1}/da^{L-1} ... dh^{i}/da^{i}\n",
- " and here we are just asking about\n",
- " 1) da^i/dW^i and 2) da^i/db^i\n",
- " since W and b are only layer's parameters\n",
- " \"\"\"\n",
- "\n",
- " grad_W = numpy.dot(inputs.T, deltas)\n",
- " grad_b = numpy.sum(deltas, axis=0)\n",
- "\n",
- " return [grad_W, grad_b]\n",
- "\n",
- " def get_params(self):\n",
- " return [self.W, self.b]\n",
- "\n",
- " def set_params(self, params):\n",
- " #we do not make checks here, but the order on the list\n",
- " #is assumed to be exactly the same as get_params() returns\n",
- " self.W = params[0]\n",
- " self.b = params[1]\n",
- "\n",
- " def get_name(self):\n",
- " return 'linear'\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Example 1: Experiment with linear models and MNIST\n",
- "\n",
- "The below snippet demonstrates how to use the code we have provided for the coursework 1. Get familiar with it, as from now on we will use till the end of the course, including the 2nd coursework.\n",
- "\n",
- "It should be straightforward to extend the following code to more complex models, like stack more layers, change the cost, the optimiser, learning rate schedules, etc.. But **ask** in case something is not clear.\n",
- "\n",
- "In this particular example, we use the following components:\n",
- " * One layer mapping data-points ($\\mathbf x$) straight to 10 digits classes represented as 10 (linear) outputs ($\\mathbf y$). This operation is implemented as a linear layer in `mlp.layers.Linear`. Get familiar with this class (read the comments, etc.) as it is going to be a building block for the coursework.\n",
- " * One can stack as many different layers as required through the container `mlp.layers.MLP`\n",
- " * As an objective here we use the Mean Square Error cost defined in `mlp.costs.MSECost`\n",
- " * Our *Stochastic Gradient Descent* optimiser can be found in `mlp.optimisers.SGDOptimiser`. Its parent `mlp.optimisers.Optimiser` implements validation functionality (and an interface in case one need to implement a different optimiser)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "import numpy\n",
- "import logging\n",
- "\n",
- "logger = logging.getLogger()\n",
- "logger.setLevel(logging.INFO)\n",
- "\n",
- "from mlp.layers import MLP, Linear #import required layer types\n",
- "from mlp.optimisers import SGDOptimiser #import the optimiser\n",
- "from mlp.dataset import MNISTDataProvider #import data provider\n",
- "from mlp.costs import MSECost #import the cost we want to use for optimisation\n",
- "from mlp.schedulers import LearningRateFixed\n",
- "\n",
- "rng = numpy.random.RandomState([2015,10,10])\n",
- "\n",
- "# define the model structure, here just one linear layer\n",
- "# and mean square error cost\n",
- "cost = MSECost()\n",
- "model = MLP(cost=cost)\n",
- "model.add_layer(Linear(idim=784, odim=10, rng=rng))\n",
- "#one can stack more layers here\n",
- "\n",
- "# define the optimiser, here stochasitc gradient descent\n",
- "# with fixed learning rate and max_epochs as stopping criterion\n",
- "lr_scheduler = LearningRateFixed(learning_rate=0.01, max_epochs=20)\n",
- "optimiser = SGDOptimiser(lr_scheduler=lr_scheduler)\n",
- "\n",
- "logger.info('Initialising data providers...')\n",
- "train_dp = MNISTDataProvider(dset='train', batch_size=100, max_num_batches=-10, randomize=True)\n",
- "valid_dp = MNISTDataProvider(dset='valid', batch_size=100, max_num_batches=-10, randomize=False)\n",
- "\n",
- "logger.info('Training started...')\n",
- "optimiser.train(model, train_dp, valid_dp)\n",
- "\n",
- "logger.info('Testing the model on test set:')\n",
- "test_dp = MNISTDataProvider(dset='eval', batch_size=100, max_num_batches=-10, randomize=False)\n",
- "cost, accuracy = optimiser.validate(model, test_dp)\n",
- "logger.info('MNIST test set accuracy is %.2f %% (cost is %.3f)'%(accuracy*100., cost))\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Exercise\n",
- "\n",
- "Modify the above code by adding an intemediate linear layer of size 200 hidden units between input and output layers."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "import numpy\n",
- "import logging\n",
- "\n",
- "logger = logging.getLogger()\n",
- "logger.setLevel(logging.INFO)\n",
- "\n",
- "from mlp.layers import MLP, Linear #import required layer types\n",
- "from mlp.optimisers import SGDOptimiser #import the optimiser\n",
- "from mlp.dataset import MNISTDataProvider #import data provider\n",
- "from mlp.costs import MSECost #import the cost we want to use for optimisation\n",
- "from mlp.schedulers import LearningRateFixed\n",
- "\n",
- "rng = numpy.random.RandomState([2015,10,10])\n",
- "\n",
- "# define the model structure, here just one linear layer\n",
- "# and mean square error cost\n",
- "cost = MSECost()\n",
- "model = MLP(cost=cost)\n",
- "model.add_layer(Linear(idim=784, odim=200, rng=rng))\n",
- "model.add_layer(Linear(idim=200, odim=10, rng=rng))\n",
- "\n",
- "# define the optimiser, here stochasitc gradient descent\n",
- "# with fixed learning rate and max_epochs as stopping criterion\n",
- "lr_scheduler = LearningRateFixed(learning_rate=0.01, max_epochs=20)\n",
- "optimiser = SGDOptimiser(lr_scheduler=lr_scheduler)\n",
- "\n",
- "logger.info('Initialising data providers...')\n",
- "train_dp = MNISTDataProvider(dset='train', batch_size=100, max_num_batches=-10, randomize=True)\n",
- "valid_dp = MNISTDataProvider(dset='valid', batch_size=100, max_num_batches=-10, randomize=False)\n",
- "\n",
- "logger.info('Training started...')\n",
- "optimiser.train(model, train_dp, valid_dp)\n",
- "\n",
- "logger.info('Testing the model on test set:')\n",
- "test_dp = MNISTDataProvider(dset='eval', batch_size=100, max_num_batches=-10, randomize=False)\n",
- "cost, accuracy = optimiser.validate(model, test_dp)\n",
- "logger.info('MNIST test set accuracy is %.2f %% (cost is %.3f)'%(accuracy*100., cost))"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 2",
- "language": "python",
- "name": "python2"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 2
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.9"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/notebooks/03_MLP_Coursework1.ipynb b/notebooks/03_MLP_Coursework1.ipynb
deleted file mode 100644
index 28be3a1..0000000
--- a/notebooks/03_MLP_Coursework1.ipynb
+++ /dev/null
@@ -1,336 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Coursework #1\n",
- "\n",
- "## Introduction\n",
- "\n",
- "This coursework is concerned with building multi-layer networks to address the MNIST digit classification problem. It builds on the previous labs, in particular [02_MNIST_SLN.ipynb](02_MNIST_SLN.ipynb) in which single layer networks were trained for MNIST digit classification. The course will involve extending that code to use Sigmoid and Softmax layers, combining these into multi-layer networks, and carrying out a number of MNIST digit classification experiments, to investigate the effect of learning rate, the number of hidden units, and the number of hidden layers.\n",
- "\n",
- "The coursework is divided into 4 tasks:\n",
- "* **Task 1**: *Implementing a sigmoid layer* - 15 marks. \n",
- "This task involves extending the `Linear` class in file `mlp/layers.py` to `Sigmoid`, with code for forward prop, backprop computation of the gradient, and weight update.\n",
- "* **Task 2**: *Implementing a softmax layer* - 15 marks. \n",
- "This task involves extending the `Linear` class in file `mlp/layers.py` to `Softmax`, with code for forward prop, backprop computation of the gradient, and weight update.\n",
- "* **Task 3**: *Constructing a multi-layer network* - 40 marks. \n",
- "This task involves putting together a Sigmoid and a Softmax layer to create a multi-layer network, with one hidden layer (100 units) and one output layer, that is trained to classify MNIST digits. This task will include reporting classification results, exploring the effect of learning rates, and plotting Hinton Diagrams for the hidden units and output units.\n",
- "* **Task 4**: *Experiments with different architectures* - 30 marks. \n",
- "This task involves further MNIST classification experiments, primarily looking at the effect of using different numbers of hidden layers.\n",
- "The coursework will be marked out of 100, and will contribute 30% of the total mark in the MLP course.\n",
- "\n",
- "## Previous Tutorials\n",
- "\n",
- "Before starting this coursework make sure that you have completed the first three labs:\n",
- "\n",
- "* [00_Introduction.ipynb](00_Introduction.ipynb) - setting up your environment; *Solutions*: [00_Introduction_solution.ipynb](00_Introduction_solution.ipynb)\n",
- "* [01_Linear_Models.ipynb](01_Linear_Models.ipynb) - training single layer networks; *Solutions*: [01_Linear_Models_solution.ipynb](01_Linear_Models_solution.ipynb)\n",
- "* [02_MNIST_SLN.ipynb](02_MNIST_SLN.ipynb) - training a single layer network for MNIST digit classification\n",
- "\n",
- "To ensure that your virtual environment is correct, please see [this note](https://github.com/CSTR-Edinburgh/mlpractical/blob/master/kernel_issue_fix.md) on the GitHub.\n",
- "## Submission\n",
- "**Submission Deadline: Thursday 29 October, 16:00** \n",
- "\n",
- "Submit the coursework as an ipython notebook file, using the `submit` command in the terminal on a DICE machine. If your file is `03_MLP_Coursework1.ipynb` then you would enter:\n",
- "\n",
- "`submit mlp 1 03_MLP_Coursework1.ipynb` \n",
- "\n",
- "where `mlp 1` indicates this is the first coursework of MLP.\n",
- "\n",
- "After submitting, you should receive an email of acknowledgment from the system confirming that your submission has been received successfully. Keep the email as evidence of your coursework submission.\n",
- "\n",
- "**Please make sure you submit a single `ipynb` file (and nothing else)!**\n",
- "\n",
- "**Submission Deadline: Thursday 29 October, 16:00** \n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Getting Started\n",
- "Please enter your exam number and the date in the next code cell."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "#MLP Coursework 1\n",
- "#Exam number: \n",
- "#Date: \n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Please run the next code cell, which imports `numpy` and seeds the random number generator. Please **do not** modify the random number generator seed!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "import numpy\n",
- "\n",
- "#Seed a random number generator running the below cell, but do **not** modify the seed.\n",
- "rng = numpy.random.RandomState([2015,10,10])\n",
- "rng_state = rng.get_state()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Task 1 - Sigmoid Layer (15%)\n",
- "\n",
- "In this task you need to create a class `Sigmoid` which encapsulates a layer of sigmoid units. You should do this by extending the `mlp.layers.Linear` class (in file `mlp/layers.py`), which implements a a layer of linear units (i.e. weighted sum plus bias). The `Sigmoid` class extends this by applying the sigmoid transfer function to the weighted sum in the forward propagation, and applying the derivative of the sigmoid in the gradient descent back propagation and computing the gradients with respect to layer's parameters. Do **not** copy the implementation provided in `Linear` class but rather, **reuse** it through inheritance.\n",
- "\n",
- "When you have implemented `Sigmoid` (in the `mlp.layers` module), then please test it by running the below code cell.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "from mlp.layers import Sigmoid\n",
- "\n",
- "a = numpy.asarray([-20.1, 52.4, 0, 0.05, 0.05, 49])\n",
- "b = numpy.asarray([-20.1, 52.4, 0, 0.05, 0.05, 49, 20, 20])\n",
- "\n",
- "rng.set_state(rng_state)\n",
- "sigm = Sigmoid(idim=a.shape[0], odim=b.shape[0], rng=rng)\n",
- "\n",
- "fp = sigm.fprop(a)\n",
- "deltas, ograds = sigm.bprop(h=fp, igrads=b)\n",
- "\n",
- "print fp.sum()\n",
- "print deltas.sum()\n",
- "print ograds.sum()\n",
- "%precision 3\n",
- "print fp\n",
- "print deltas\n",
- "print ograds\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "***\n",
- "To include the `Sigmoid` code in the notebook please run the below code cell. (The `%load` notebook command is used to load the source of the `Sigmoid` class from `mlp/layers.py`.)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "%load -s Sigmoid mlp/layers.py"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Task 2 - Softmax (15%)\n",
- "\n",
- "In this task you need to create a class `Softmax` which encapsulates a layer of softmax units. As in the previous task, you should do this by extending the `mlp.layers.Linear` class (in file `mlp/layers.py`).\n",
- "\n",
- "When you have implemented `Softmax` (in the `mlp.layers` module), then please test it by running the below code cell.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "from mlp.layers import Softmax\n",
- "\n",
- "a = numpy.asarray([-20.1, 52.4, 0, 0.05, 0.05, 49])\n",
- "b = numpy.asarray([0, 0, 0, 0, 0, 0, 0, 1])\n",
- "\n",
- "rng.set_state(rng_state)\n",
- "softmax = Softmax(idim=a.shape[0], odim=b.shape[0], rng=rng)\n",
- "\n",
- "fp = softmax.fprop(a)\n",
- "deltas, ograds = softmax.bprop_cost(h=None, igrads=fp-b, cost=None)\n",
- "\n",
- "print fp.sum()\n",
- "print deltas.sum()\n",
- "print ograds.sum()\n",
- "%precision 3\n",
- "print fp\n",
- "print deltas\n",
- "print ograds\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "***\n",
- "To include the `Softmax` code in the notebook please run the below code cell. (The notebook `%load` command is used to load the source of the `Softmax` class from `mlp/layers.py`.)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "%load -s Softmax mlp/layers.py"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Task 3 - Multi-layer network for MNIST classification (40%)\n",
- "\n",
- "**(a)** (20%) Building on the single layer linear network for MNIST classification used in lab [02_MNIST_SLN.ipynb](02_MNIST_SLN.ipynb), and using the `Sigmoid` and `Softmax` classes that you implemented in tasks 1 and 2, construct and learn a model that classifies MNIST images and:\n",
- " * Has one hidden layer with a sigmoid transfer function and 100 units\n",
- " * Uses a softmax output layer to discriminate between the 10 digit classes (use the `mlp.costs.CECost()` cost)\n",
- "\n",
- "Your code should print the final values of the error function and the classification accuracy for train, validation, and test sets (please keep also the log information printed by default by the optimiser). Limit the number of training epochs to 30. You can, of course, split your code across as many cells as you think is necessary."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "# include here the complete code that constructs the model, performs training,\n",
- "# and prints the error and accuracy for train/valid/test"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "**(b)** (10%) Investigate the impact of different learning rates $\\eta \\in \\{0.5, 0.2, 0.1, 0.05, 0.01, 0.005\\}$ on the convergence of the network training as well as the final accuracy:\n",
- " * Plot (on a single graph) the error rate curves for each learning rate as a function of training epochs for training set\n",
- " * Plot (on another single graph) the error rate curves as a function of training epochs for validation set\n",
- " * Include a table of the corresponding error rates for test set\n",
- "\n",
- "The notebook command `%matplotlib inline` ensures that your graphs will be added to the notebook, rather than opened as additional windows."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "%matplotlib inline"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "**(c)** (10%) Plot the following graphs:\n",
- " * Display the 784-element weight vector of each of the 100 hidden units as 10x10 grid plot of 28x28 images, in order to visualise what features of the input they are encoding. To do this, take the weight vector of each hidden unit, reshape to 28x28, and plot using the `imshow` function).\n",
- " * Plot a Hinton Diagram of the output layer weight matrix for digits 0 and 1"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "%matplotlib inline"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "collapsed": true
- },
- "source": [
- "## Task 4 - Experiments with 1-5 hidden layers (30%)\n",
- "\n",
- "In this task use the learning rate which resulted in the best accuracy in your experiments in Task 3 (b). Perform the following experiments:\n",
- "\n",
- " * Train a similar model to Task 3, with one hidden layer, but with 800 hidden units. \n",
- " * Train 4 additional models with 2, 3, 4 and 5 hidden layers. Set the number of hidden units for each model, such that all the models have similar number of trainable weights ($\\pm$2%). For simplicity, for a given model, keep the number of units in each hidden layer the same.\n",
- " * Plot value of the error function for training and validation sets as a function of training epochs for each model\n",
- " * Plot the test set classification accuracy as a function of the number of hidden layers\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "collapsed": true
- },
- "source": [
- "This is the end of coursework 1.\n",
- "\n",
- "Please remember to save your notebook, and submit your notebook following the instructions at the top. Please make sure that you have executed all the code cells when you submit the notebook.\n"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 2",
- "language": "python",
- "name": "python2"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 2
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.9"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/notebooks/02_MNIST_SLN.ipynb b/notebooks/03_Multi_layer_models.ipynb
similarity index 100%
rename from notebooks/02_MNIST_SLN.ipynb
rename to notebooks/03_Multi_layer_models.ipynb
diff --git a/notebooks/04_Regularisation_solution.ipynb b/notebooks/04_Regularisation_solution.ipynb
deleted file mode 100644
index 37095a3..0000000
--- a/notebooks/04_Regularisation_solution.ipynb
+++ /dev/null
@@ -1,1056 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Introduction\n",
- "\n",
- "This tutorial focuses on implementation of three reqularisaion techniques, two of them are norm based approaches which are added to optimised objective and the third technique, called *droput*, is a form of noise injection by random corruption of information carried by hidden units during training.\n",
- "\n",
- "\n",
- "## Virtual environments\n",
- "\n",
- "Before you proceed onwards, remember to activate your virtual environment:\n",
- " * If you were in last week's Tuesday or Wednesday group type `activate_mlp` or `source ~/mlpractical/venv/bin/activate`\n",
- " * If you were in the Monday group:\n",
- " + and if you have chosen the **comfy** way type: `workon mlpractical`\n",
- " + and if you have chosen the **generic** way, `source` your virutal environment using `source` and specyfing the path to the activate script (you need to localise it yourself, there were not any general recommendations w.r.t dir structure and people have installed it in different places, usually somewhere in the home directories. If you cannot easily find it by yourself, use something like: `find . -iname activate` ):\n",
- "\n",
- "## Syncing the git repository\n",
- "\n",
- "Look here for more details. But in short, we recommend to create a separate branch for this lab, as follows:\n",
- "\n",
- "1. Enter the mlpractical directory `cd ~/mlpractical/repo-mlp`\n",
- "2. List the branches and check which is currently active by typing: `git branch`\n",
- "3. If you have followed our recommendations, you should be in the `coursework1` branch, please commit your local changed to the repo index by typing:\n",
- "```\n",
- "git commit -am \"finished coursework\"\n",
- "```\n",
- "4. Now you can switch to `master` branch by typing: \n",
- "```\n",
- "git checkout master\n",
- " ```\n",
- "5. To update the repository (note, assuming master does not have any conflicts), if there are some, have a look here\n",
- "```\n",
- "git pull\n",
- "```\n",
- "6. And now, create the new branch & swith to it by typing:\n",
- "```\n",
- "git checkout -b lab4\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Regularisation\n",
- "\n",
- "Regularisation add some *complexity term* to the cost function. It's purpose is to put some prior on the model's parameters. The most common prior is perhaps the one which assumes smoother solutions (the one which are not able to fit training data too well) are better as they are more likely to better generalise to unseen data. \n",
- "\n",
- "A way to incorporate such prior in the model is to add some term that penalise certain configurations of the parameters -- either from growing too large ($L_2$) or the one that prefers solution that could be modelled with less parameters ($L_1$), hence encouraging some parameters to become 0. One can, of course, combine many such priors when optimising the model, however, in the lab we shall use $L_1$ and/or $L_2$ priors.\n",
- "\n",
- "They can be easily incorporated into the training objective by adding some additive terms, as follows:\n",
- "\n",
- "(1) $\n",
- " \\begin{align*}\n",
- " E^n &= \\underbrace{E^n_{\\text{train}}}_{\\text{data term}} + \n",
- " \\underbrace{\\beta_{L_1} E^n_{L_1}}_{\\text{prior term}} + \\underbrace{\\beta_{L_2} E^n_{L_2}}_{\\text{prior term}}\n",
- "\\end{align*}\n",
- "$\n",
- "\n",
- "where $ E^n_{\\text{train}} = - \\sum_{k=1}^K t^n_k \\ln y^n_k $, $\\beta_{L_1}$ and $\\beta_{L_2}$ some non-negative constants specified a priori (hyper-parameters) and $E^n_{L_1}$ and $E^n_{L_2}$ norm metric specifying certain properties of parameters:\n",
- "\n",
- "(2) $\n",
- " \\begin{align*}\n",
- " E^n_{L_p}(\\mathbf{W}) = \\left ( \\sum_{i,j \\in \\mathbf{W}} |w_{i,j}|^p \\right )^{\\frac{1}{p}}\n",
- "\\end{align*}\n",
- "$\n",
- "\n",
- "where $p$ denotes the norm-order (for regularisation either 1 or 2). (TODO: explain here why we usualy skip square root for p=2)\n",
- "\n",
- "## $L_{p=2}$ (Weight Decay)\n",
- "\n",
- "(3) $\n",
- " \\begin{align*}\n",
- " E^n &= \\underbrace{E^n_{\\text{train}}}_{\\text{data term}} + \n",
- " \\underbrace{\\beta E^n_{L_2}}_{\\text{prior term}} = E^n_{\\text{train}} + \\beta_{L_2} \\frac{1}{2}|w_i|^2\n",
- "\\end{align*}\n",
- "$\n",
- "\n",
- "(4) $\n",
- "\\begin{align*}\\frac{\\partial E^n}{\\partial w_i} &= \\frac{\\partial (E^n_{\\text{train}} + \\beta_{L_2} E_{L_2}) }{\\partial w_i} \n",
- " = \\left( \\frac{\\partial E^n_{\\text{train}}}{\\partial w_i} + \\beta_{L_2} \\frac{\\partial\n",
- " E_{L_2}}{\\partial w_i} \\right) \n",
- " = \\left( \\frac{\\partial E^n_{\\text{train}}}{\\partial w_i} + \\beta_{L_2} w_i \\right)\n",
- "\\end{align*}\n",
- "$\n",
- "\n",
- "(5) $\n",
- "\\begin{align*}\n",
- " \\Delta w_i &= -\\eta \\left( \\frac{\\partial E^n_{\\text{train}}}{\\partial w_i} + \\beta_{L_2} w_i \\right) \n",
- "\\end{align*}\n",
- "$\n",
- "\n",
- "where $\\eta$ is learning rate.\n",
- "\n",
- "## $L_{p=1}$ (Sparsity)\n",
- "\n",
- "(6) $\n",
- " \\begin{align*}\n",
- " E^n &= \\underbrace{E^n_{\\text{train}}}_{\\text{data term}} + \n",
- " \\underbrace{\\beta E^n_{L_1}}_{\\text{prior term}} \n",
- " = E^n_{\\text{train}} + \\beta_{L_1} |w_i|\n",
- "\\end{align*}\n",
- "$\n",
- "\n",
- "(7) $\\begin{align*}\n",
- " \\frac{\\partial E^n}{\\partial w_i} = \\frac{\\partial E^n_{\\text{train}}}{\\partial w_i} + \\beta_{L_1} \\frac{\\partial E_{L_1}}{\\partial w_i} = \\frac{\\partial E^n_{\\text{train}}}{\\partial w_i} + \\beta_{L_1} \\mbox{sgn}(w_i)\n",
- "\\end{align*}\n",
- "$\n",
- "\n",
- "(8) $\\begin{align*}\n",
- " \\Delta w_i &= -\\eta \\left( \\frac{\\partial E^n_{\\text{train}}}{\\partial w_i} + \\beta_{L_1} \\mbox{sgn}(w_i) \\right) \n",
- "\\end{align*}$\n",
- "\n",
- "Where $\\mbox{sgn}(w_i)$ is the sign of $w_i$: $\\mbox{sgn}(w_i) = 1$ if $w_i>0$ and $\\mbox{sgn}(w_i) = -1$ if $w_i<0$\n",
- "\n",
- "One can also apply those penalty terms for biases, however, this is usually not necessary as biases have secondary impact on smoothnes of the given solution.\n",
- "\n",
- "## Dropout\n",
- "\n",
- "Dropout, for a given layer's output $\\mathbf{h}^i \\in \\mathbb{R}^{BxH^l}$ (where $B$ is batch size and $H^l$ is the $l$-th layer output dimensionality) implements the following transformation:\n",
- "\n",
- "(9) $\\mathbf{\\hat h}^l = \\mathbf{d}^l\\circ\\mathbf{h}^l$\n",
- "\n",
- "where $\\circ$ denotes an elementwise product and $\\mathbf{d}^l \\in \\{0,1\\}^{BxH^i}$ is a matrix in which $d^l_{ij}$ element is sampled from the Bernoulli distribution:\n",
- "\n",
- "(10) $d^l_{ij} \\sim \\mbox{Bernoulli}(p^l_d)$\n",
- "\n",
- "with $0"
- ]
- },
- "execution_count": 17,
- "metadata": {},
- "output_type": "execute_result"
- },
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWwAAAD7CAYAAABOi672AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n+B95ZPpm8QyaLgAAAABJRU5ErkJggg==\n",
- "text/plain": [
- ""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "%pylab\n",
- "%matplotlib inline\n",
- "\n",
- "train_dp.reset()\n",
- "x, t = train_dp.next()\n",
- "img = x[0].reshape(28,28)\n",
- "pds = [0.9, 0.7, 0.5, 0.2, 0.1]\n",
- "imgs = [None] * (len(pds)+1)\n",
- "imgs[0] = img\n",
- "\n",
- "for i, pd in enumerate(pds):\n",
- " d = rng.binomial(1, pd, img.shape)\n",
- " imgs[i + 1] = d*img\n",
- "\n",
- "fig, ax = plt.subplots(2,3)\n",
- "ax[0, 0].imshow(imgs[0], cmap=cm.Greys_r)\n",
- "ax[0, 1].imshow(imgs[1], cmap=cm.Greys_r)\n",
- "ax[0, 2].imshow(imgs[2], cmap=cm.Greys_r)\n",
- "ax[1, 0].imshow(imgs[3], cmap=cm.Greys_r)\n",
- "ax[1, 1].imshow(imgs[4], cmap=cm.Greys_r)\n",
- "ax[1, 2].imshow(imgs[5], cmap=cm.Greys_r)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Exercise 4: Implement Dropout \n",
- "\n",
- "Implement dropout regularisation technique. Then for the same initial configuration as in Exercise 1. investigate effectivness of different dropout rates applied to input features and/or hidden layers. Start with $p_{inp}=0.5$ and $p_{hid}=0.5$ and do some search for better settings.\n",
- "\n",
- "Implementation tips:\n",
- "* Add a function `fprop_dropout` to `mlp.layers.MLP` class which (on top of `inputs` argument) takes also dropout-related argument(s) and perform dropout forward propagation through the model.\n",
- "* One also would have to introduce required modificastions to `mlp.optimisers.SGDOptimiser.train_epoch()` function.\n",
- "* Design and implemnt dropout scheduler in a similar way to how learning rates are handled (that is, allowing for some implementation dependent schedule which is kept independent of implementation in `mlp.optimisers.SGDOptimiser.train()`). \n",
- " + For this exercise implement only fixed dropout scheduler - `DropoutFixed`, but implementation should allow to easily add other schedules in the future. \n",
- " + Dropout scheduler of any type should return a tuple of two numbers $(p_{inp},\\; p_{hid})$, the first one is dropout factor for input features (data-points), and the latter dropout factor for hidden layers (assumed the same for all hidden layers)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "collapsed": false,
- "scrolled": true
- },
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "ERROR: Line magic function `%autoreload` not found.\n",
- "INFO:root:Training started...\n",
- "INFO:mlp.optimisers:Epoch 0: Training cost (ce) for initial model is 2.624. Accuracy is 8.60%\n",
- "INFO:mlp.optimisers:Epoch 0: Validation cost (ce) for initial model is 2.554. Accuracy is 9.84%\n",
- "INFO:mlp.optimisers:Epoch 1: Training cost (ce) is 3.224. Accuracy is 43.80%\n",
- "INFO:mlp.optimisers:Epoch 1: Validation cost (ce) is 0.633. Accuracy is 81.88%\n",
- "INFO:mlp.optimisers:Epoch 1: Took 10 seconds. Training speed 273 pps. Validation speed 1678 pps.\n",
- "INFO:mlp.optimisers:Epoch 2: Training cost (ce) is 0.957. Accuracy is 68.80%\n",
- "INFO:mlp.optimisers:Epoch 2: Validation cost (ce) is 0.523. Accuracy is 84.89%\n",
- "INFO:mlp.optimisers:Epoch 2: Took 10 seconds. Training speed 247 pps. Validation speed 1687 pps.\n",
- "INFO:mlp.optimisers:Epoch 3: Training cost (ce) is 0.797. Accuracy is 73.50%\n",
- "INFO:mlp.optimisers:Epoch 3: Validation cost (ce) is 0.613. Accuracy is 80.22%\n",
- "INFO:mlp.optimisers:Epoch 3: Took 10 seconds. Training speed 237 pps. Validation speed 1692 pps.\n",
- "INFO:mlp.optimisers:Epoch 4: Training cost (ce) is 0.730. Accuracy is 74.80%\n",
- "INFO:mlp.optimisers:Epoch 4: Validation cost (ce) is 0.442. Accuracy is 86.47%\n",
- "INFO:mlp.optimisers:Epoch 4: Took 10 seconds. Training speed 242 pps. Validation speed 1687 pps.\n",
- "INFO:mlp.optimisers:Epoch 5: Training cost (ce) is 0.596. Accuracy is 79.60%\n",
- "INFO:mlp.optimisers:Epoch 5: Validation cost (ce) is 0.410. Accuracy is 87.96%\n",
- "INFO:mlp.optimisers:Epoch 5: Took 10 seconds. Training speed 239 pps. Validation speed 1710 pps.\n",
- "INFO:mlp.optimisers:Epoch 6: Training cost (ce) is 0.598. Accuracy is 80.20%\n",
- "INFO:mlp.optimisers:Epoch 6: Validation cost (ce) is 0.388. Accuracy is 88.27%\n",
- "INFO:mlp.optimisers:Epoch 6: Took 10 seconds. Training speed 248 pps. Validation speed 1681 pps.\n",
- "INFO:mlp.optimisers:Epoch 7: Training cost (ce) is 0.513. Accuracy is 84.10%\n",
- "INFO:mlp.optimisers:Epoch 7: Validation cost (ce) is 0.426. Accuracy is 87.53%\n",
- "INFO:mlp.optimisers:Epoch 7: Took 10 seconds. Training speed 245 pps. Validation speed 1687 pps.\n",
- "INFO:mlp.optimisers:Epoch 8: Training cost (ce) is 0.451. Accuracy is 85.20%\n",
- "INFO:mlp.optimisers:Epoch 8: Validation cost (ce) is 0.383. Accuracy is 88.44%\n",
- "INFO:mlp.optimisers:Epoch 8: Took 10 seconds. Training speed 255 pps. Validation speed 1681 pps.\n",
- "INFO:mlp.optimisers:Epoch 9: Training cost (ce) is 0.507. Accuracy is 82.70%\n",
- "INFO:mlp.optimisers:Epoch 9: Validation cost (ce) is 0.380. Accuracy is 89.12%\n",
- "INFO:mlp.optimisers:Epoch 9: Took 10 seconds. Training speed 266 pps. Validation speed 1718 pps.\n",
- "INFO:mlp.optimisers:Epoch 10: Training cost (ce) is 0.464. Accuracy is 83.70%\n",
- "INFO:mlp.optimisers:Epoch 10: Validation cost (ce) is 0.333. Accuracy is 90.46%\n",
- "INFO:mlp.optimisers:Epoch 10: Took 10 seconds. Training speed 245 pps. Validation speed 1698 pps.\n",
- "INFO:mlp.optimisers:Epoch 11: Training cost (ce) is 0.399. Accuracy is 87.40%\n",
- "INFO:mlp.optimisers:Epoch 11: Validation cost (ce) is 0.334. Accuracy is 90.56%\n",
- "INFO:mlp.optimisers:Epoch 11: Took 10 seconds. Training speed 246 pps. Validation speed 1672 pps.\n",
- "INFO:mlp.optimisers:Epoch 12: Training cost (ce) is 0.422. Accuracy is 86.30%\n",
- "INFO:mlp.optimisers:Epoch 12: Validation cost (ce) is 0.348. Accuracy is 89.54%\n",
- "INFO:mlp.optimisers:Epoch 12: Took 10 seconds. Training speed 239 pps. Validation speed 1687 pps.\n",
- "INFO:mlp.optimisers:Epoch 13: Training cost (ce) is 0.396. Accuracy is 86.20%\n",
- "INFO:mlp.optimisers:Epoch 13: Validation cost (ce) is 0.348. Accuracy is 89.37%\n",
- "INFO:mlp.optimisers:Epoch 13: Took 10 seconds. Training speed 236 pps. Validation speed 1692 pps.\n",
- "INFO:mlp.optimisers:Epoch 14: Training cost (ce) is 0.360. Accuracy is 88.40%\n",
- "INFO:mlp.optimisers:Epoch 14: Validation cost (ce) is 0.354. Accuracy is 89.56%\n",
- "INFO:mlp.optimisers:Epoch 14: Took 10 seconds. Training speed 248 pps. Validation speed 1675 pps.\n",
- "INFO:mlp.optimisers:Epoch 15: Training cost (ce) is 0.362. Accuracy is 87.20%\n",
- "INFO:mlp.optimisers:Epoch 15: Validation cost (ce) is 0.351. Accuracy is 89.66%\n",
- "INFO:mlp.optimisers:Epoch 15: Took 10 seconds. Training speed 252 pps. Validation speed 1695 pps.\n",
- "INFO:mlp.optimisers:Epoch 16: Training cost (ce) is 0.325. Accuracy is 88.40%\n",
- "INFO:mlp.optimisers:Epoch 16: Validation cost (ce) is 0.322. Accuracy is 90.95%\n",
- "INFO:mlp.optimisers:Epoch 16: Took 10 seconds. Training speed 256 pps. Validation speed 1684 pps.\n",
- "INFO:mlp.optimisers:Epoch 17: Training cost (ce) is 0.351. Accuracy is 88.40%\n",
- "INFO:mlp.optimisers:Epoch 17: Validation cost (ce) is 0.334. Accuracy is 90.02%\n",
- "INFO:mlp.optimisers:Epoch 17: Took 10 seconds. Training speed 246 pps. Validation speed 1684 pps.\n",
- "INFO:mlp.optimisers:Epoch 18: Training cost (ce) is 0.277. Accuracy is 91.80%\n",
- "INFO:mlp.optimisers:Epoch 18: Validation cost (ce) is 0.329. Accuracy is 90.35%\n",
- "INFO:mlp.optimisers:Epoch 18: Took 10 seconds. Training speed 265 pps. Validation speed 1698 pps.\n",
- "INFO:mlp.optimisers:Epoch 19: Training cost (ce) is 0.297. Accuracy is 89.50%\n",
- "INFO:mlp.optimisers:Epoch 19: Validation cost (ce) is 0.308. Accuracy is 91.28%\n",
- "INFO:mlp.optimisers:Epoch 19: Took 10 seconds. Training speed 245 pps. Validation speed 1678 pps.\n",
- "INFO:mlp.optimisers:Epoch 20: Training cost (ce) is 0.295. Accuracy is 90.20%\n",
- "INFO:mlp.optimisers:Epoch 20: Validation cost (ce) is 0.319. Accuracy is 90.59%\n",
- "INFO:mlp.optimisers:Epoch 20: Took 10 seconds. Training speed 246 pps. Validation speed 1689 pps.\n",
- "INFO:mlp.optimisers:Epoch 21: Training cost (ce) is 0.289. Accuracy is 90.10%\n",
- "INFO:mlp.optimisers:Epoch 21: Validation cost (ce) is 0.298. Accuracy is 91.54%\n",
- "INFO:mlp.optimisers:Epoch 21: Took 10 seconds. Training speed 251 pps. Validation speed 1689 pps.\n",
- "INFO:mlp.optimisers:Epoch 22: Training cost (ce) is 0.248. Accuracy is 92.10%\n",
- "INFO:mlp.optimisers:Epoch 22: Validation cost (ce) is 0.315. Accuracy is 90.82%\n",
- "INFO:mlp.optimisers:Epoch 22: Took 10 seconds. Training speed 250 pps. Validation speed 1689 pps.\n",
- "INFO:mlp.optimisers:Epoch 23: Training cost (ce) is 0.268. Accuracy is 90.40%\n",
- "INFO:mlp.optimisers:Epoch 23: Validation cost (ce) is 0.309. Accuracy is 90.99%\n",
- "INFO:mlp.optimisers:Epoch 23: Took 10 seconds. Training speed 242 pps. Validation speed 1712 pps.\n",
- "INFO:mlp.optimisers:Epoch 24: Training cost (ce) is 0.257. Accuracy is 90.70%\n",
- "INFO:mlp.optimisers:Epoch 24: Validation cost (ce) is 0.300. Accuracy is 91.57%\n",
- "INFO:mlp.optimisers:Epoch 24: Took 10 seconds. Training speed 248 pps. Validation speed 1684 pps.\n",
- "INFO:mlp.optimisers:Epoch 25: Training cost (ce) is 0.240. Accuracy is 91.30%\n",
- "INFO:mlp.optimisers:Epoch 25: Validation cost (ce) is 0.297. Accuracy is 91.10%\n",
- "INFO:mlp.optimisers:Epoch 25: Took 10 seconds. Training speed 246 pps. Validation speed 1692 pps.\n",
- "INFO:mlp.optimisers:Epoch 26: Training cost (ce) is 0.242. Accuracy is 91.10%\n",
- "INFO:mlp.optimisers:Epoch 26: Validation cost (ce) is 0.297. Accuracy is 91.43%\n",
- "INFO:mlp.optimisers:Epoch 26: Took 10 seconds. Training speed 277 pps. Validation speed 1681 pps.\n",
- "INFO:mlp.optimisers:Epoch 27: Training cost (ce) is 0.228. Accuracy is 93.10%\n",
- "INFO:mlp.optimisers:Epoch 27: Validation cost (ce) is 0.289. Accuracy is 92.07%\n",
- "INFO:mlp.optimisers:Epoch 27: Took 10 seconds. Training speed 245 pps. Validation speed 1687 pps.\n",
- "INFO:mlp.optimisers:Epoch 28: Training cost (ce) is 0.241. Accuracy is 92.60%\n",
- "INFO:mlp.optimisers:Epoch 28: Validation cost (ce) is 0.320. Accuracy is 90.39%\n",
- "INFO:mlp.optimisers:Epoch 28: Took 10 seconds. Training speed 246 pps. Validation speed 1698 pps.\n",
- "INFO:mlp.optimisers:Epoch 29: Training cost (ce) is 0.227. Accuracy is 92.20%\n",
- "INFO:mlp.optimisers:Epoch 29: Validation cost (ce) is 0.283. Accuracy is 91.96%\n",
- "INFO:mlp.optimisers:Epoch 29: Took 10 seconds. Training speed 234 pps. Validation speed 1715 pps.\n",
- "INFO:mlp.optimisers:Epoch 30: Training cost (ce) is 0.217. Accuracy is 93.20%\n",
- "INFO:mlp.optimisers:Epoch 30: Validation cost (ce) is 0.299. Accuracy is 91.30%\n",
- "INFO:mlp.optimisers:Epoch 30: Took 10 seconds. Training speed 268 pps. Validation speed 1730 pps.\n",
- "INFO:mlp.optimisers:Epoch 31: Training cost (ce) is 0.191. Accuracy is 93.60%\n",
- "INFO:mlp.optimisers:Epoch 31: Validation cost (ce) is 0.277. Accuracy is 92.34%\n",
- "INFO:mlp.optimisers:Epoch 31: Took 10 seconds. Training speed 254 pps. Validation speed 1692 pps.\n",
- "INFO:mlp.optimisers:Epoch 32: Training cost (ce) is 0.212. Accuracy is 93.40%\n",
- "INFO:mlp.optimisers:Epoch 32: Validation cost (ce) is 0.287. Accuracy is 91.60%\n",
- "INFO:mlp.optimisers:Epoch 32: Took 11 seconds. Training speed 215 pps. Validation speed 1710 pps.\n",
- "INFO:mlp.optimisers:Epoch 33: Training cost (ce) is 0.170. Accuracy is 94.30%\n",
- "INFO:mlp.optimisers:Epoch 33: Validation cost (ce) is 0.302. Accuracy is 91.77%\n",
- "INFO:mlp.optimisers:Epoch 33: Took 10 seconds. Training speed 244 pps. Validation speed 1724 pps.\n",
- "INFO:mlp.optimisers:Epoch 34: Training cost (ce) is 0.206. Accuracy is 93.30%\n",
- "INFO:mlp.optimisers:Epoch 34: Validation cost (ce) is 0.277. Accuracy is 92.13%\n",
- "INFO:mlp.optimisers:Epoch 34: Took 11 seconds. Training speed 213 pps. Validation speed 1701 pps.\n",
- "INFO:mlp.optimisers:Epoch 35: Training cost (ce) is 0.191. Accuracy is 93.80%\n",
- "INFO:mlp.optimisers:Epoch 35: Validation cost (ce) is 0.286. Accuracy is 92.08%\n",
- "INFO:mlp.optimisers:Epoch 35: Took 10 seconds. Training speed 253 pps. Validation speed 1678 pps.\n",
- "INFO:mlp.optimisers:Epoch 36: Training cost (ce) is 0.191. Accuracy is 92.00%\n",
- "INFO:mlp.optimisers:Epoch 36: Validation cost (ce) is 0.289. Accuracy is 91.89%\n",
- "INFO:mlp.optimisers:Epoch 36: Took 11 seconds. Training speed 194 pps. Validation speed 1687 pps.\n",
- "INFO:mlp.optimisers:Epoch 37: Training cost (ce) is 0.190. Accuracy is 92.70%\n",
- "INFO:mlp.optimisers:Epoch 37: Validation cost (ce) is 0.280. Accuracy is 92.15%\n",
- "INFO:mlp.optimisers:Epoch 37: Took 11 seconds. Training speed 192 pps. Validation speed 1678 pps.\n",
- "INFO:mlp.optimisers:Epoch 38: Training cost (ce) is 0.200. Accuracy is 93.50%\n",
- "INFO:mlp.optimisers:Epoch 38: Validation cost (ce) is 0.317. Accuracy is 91.17%\n",
- "INFO:mlp.optimisers:Epoch 38: Took 11 seconds. Training speed 186 pps. Validation speed 1684 pps.\n",
- "INFO:mlp.optimisers:Epoch 39: Training cost (ce) is 0.198. Accuracy is 93.30%\n",
- "INFO:mlp.optimisers:Epoch 39: Validation cost (ce) is 0.301. Accuracy is 91.26%\n",
- "INFO:mlp.optimisers:Epoch 39: Took 11 seconds. Training speed 194 pps. Validation speed 1678 pps.\n",
- "INFO:mlp.optimisers:Epoch 40: Training cost (ce) is 0.159. Accuracy is 94.90%\n",
- "INFO:mlp.optimisers:Epoch 40: Validation cost (ce) is 0.277. Accuracy is 92.25%\n",
- "INFO:mlp.optimisers:Epoch 40: Took 11 seconds. Training speed 212 pps. Validation speed 1667 pps.\n",
- "INFO:mlp.optimisers:Epoch 41: Training cost (ce) is 0.150. Accuracy is 94.70%\n",
- "INFO:mlp.optimisers:Epoch 41: Validation cost (ce) is 0.265. Accuracy is 92.79%\n",
- "INFO:mlp.optimisers:Epoch 41: Took 11 seconds. Training speed 195 pps. Validation speed 1710 pps.\n",
- "INFO:mlp.optimisers:Epoch 42: Training cost (ce) is 0.147. Accuracy is 95.20%\n",
- "INFO:mlp.optimisers:Epoch 42: Validation cost (ce) is 0.268. Accuracy is 92.54%\n",
- "INFO:mlp.optimisers:Epoch 42: Took 10 seconds. Training speed 238 pps. Validation speed 1684 pps.\n",
- "INFO:mlp.optimisers:Epoch 43: Training cost (ce) is 0.171. Accuracy is 93.90%\n",
- "INFO:mlp.optimisers:Epoch 43: Validation cost (ce) is 0.281. Accuracy is 91.75%\n",
- "INFO:mlp.optimisers:Epoch 43: Took 10 seconds. Training speed 229 pps. Validation speed 1713 pps.\n",
- "INFO:mlp.optimisers:Epoch 44: Training cost (ce) is 0.123. Accuracy is 95.50%\n",
- "INFO:mlp.optimisers:Epoch 44: Validation cost (ce) is 0.276. Accuracy is 92.50%\n",
- "INFO:mlp.optimisers:Epoch 44: Took 11 seconds. Training speed 210 pps. Validation speed 1678 pps.\n",
- "INFO:mlp.optimisers:Epoch 45: Training cost (ce) is 0.136. Accuracy is 95.30%\n",
- "INFO:mlp.optimisers:Epoch 45: Validation cost (ce) is 0.288. Accuracy is 91.73%\n",
- "INFO:mlp.optimisers:Epoch 45: Took 11 seconds. Training speed 185 pps. Validation speed 1675 pps.\n",
- "INFO:mlp.optimisers:Epoch 46: Training cost (ce) is 0.178. Accuracy is 93.60%\n",
- "INFO:mlp.optimisers:Epoch 46: Validation cost (ce) is 0.286. Accuracy is 92.01%\n",
- "INFO:mlp.optimisers:Epoch 46: Took 11 seconds. Training speed 213 pps. Validation speed 1672 pps.\n",
- "INFO:mlp.optimisers:Epoch 47: Training cost (ce) is 0.139. Accuracy is 95.40%\n",
- "INFO:mlp.optimisers:Epoch 47: Validation cost (ce) is 0.262. Accuracy is 92.84%\n",
- "INFO:mlp.optimisers:Epoch 47: Took 11 seconds. Training speed 186 pps. Validation speed 1687 pps.\n",
- "INFO:mlp.optimisers:Epoch 48: Training cost (ce) is 0.141. Accuracy is 95.30%\n",
- "INFO:mlp.optimisers:Epoch 48: Validation cost (ce) is 0.265. Accuracy is 92.80%\n",
- "INFO:mlp.optimisers:Epoch 48: Took 11 seconds. Training speed 199 pps. Validation speed 1675 pps.\n",
- "INFO:mlp.optimisers:Epoch 49: Training cost (ce) is 0.120. Accuracy is 95.50%\n",
- "INFO:mlp.optimisers:Epoch 49: Validation cost (ce) is 0.261. Accuracy is 92.97%\n",
- "INFO:mlp.optimisers:Epoch 49: Took 11 seconds. Training speed 206 pps. Validation speed 1684 pps.\n",
- "INFO:mlp.optimisers:Epoch 50: Training cost (ce) is 0.123. Accuracy is 96.10%\n",
- "INFO:mlp.optimisers:Epoch 50: Validation cost (ce) is 0.272. Accuracy is 92.63%\n",
- "INFO:mlp.optimisers:Epoch 50: Took 10 seconds. Training speed 248 pps. Validation speed 1670 pps.\n",
- "INFO:root:Testing the model on test set:\n",
- "INFO:root:MNIST test set accuracy is 91.94 %, cost (ce) is 0.291\n"
- ]
- }
- ],
- "source": [
- "%autoreload\n",
- "\n",
- "import numpy\n",
- "import logging\n",
- "\n",
- "from mlp.layers import MLP, Linear, Sigmoid, Softmax #import required layer types\n",
- "from mlp.optimisers import SGDOptimiser #import the optimiser\n",
- "from mlp.dataset import MNISTDataProvider #import data provider\n",
- "from mlp.costs import CECost #import the cost we want to use for optimisation\n",
- "from mlp.schedulers import LearningRateFixed, DropoutFixed\n",
- "\n",
- "logger = logging.getLogger()\n",
- "logger.setLevel(logging.INFO)\n",
- "rng = numpy.random.RandomState([2015,10,10])\n",
- "\n",
- "#some hyper-parameters\n",
- "nhid = 800\n",
- "learning_rate = 0.5\n",
- "max_epochs = 50\n",
- "l1_weight = 0.0\n",
- "l2_weight = 0.0\n",
- "cost = CECost()\n",
- " \n",
- "stats = []\n",
- "layer = 1\n",
- "for i in xrange(1, 2):\n",
- "\n",
- " train_dp.reset()\n",
- " valid_dp.reset()\n",
- " test_dp.reset()\n",
- " \n",
- " #define the model\n",
- " model = MLP(cost=cost)\n",
- " model.add_layer(Sigmoid(idim=784, odim=nhid, irange=0.2, rng=rng))\n",
- " for i in xrange(1, layer):\n",
- " logger.info(\"Stacking hidden layer (%s)\" % str(i+1))\n",
- " model.add_layer(Sigmoid(idim=nhid, odim=nhid, irange=0.2, rng=rng))\n",
- " model.add_layer(Softmax(idim=nhid, odim=10, rng=rng))\n",
- "\n",
- " # define the optimiser, here stochasitc gradient descent\n",
- " # with fixed learning rate and max_epochs\n",
- " lr_scheduler = LearningRateFixed(learning_rate=learning_rate, max_epochs=max_epochs)\n",
- " dp_scheduler = DropoutFixed(0.5, 0.5)\n",
- " optimiser = SGDOptimiser(lr_scheduler=lr_scheduler, \n",
- " dp_scheduler=dp_scheduler,\n",
- " l1_weight=l1_weight, \n",
- " l2_weight=l2_weight)\n",
- "\n",
- " logger.info('Training started...')\n",
- " tr_stats, valid_stats = optimiser.train(model, train_dp, valid_dp)\n",
- "\n",
- " logger.info('Testing the model on test set:')\n",
- " tst_cost, tst_accuracy = optimiser.validate(model, test_dp)\n",
- " logger.info('MNIST test set accuracy is %.2f %%, cost (%s) is %.3f'%(tst_accuracy*100., cost.get_name(), tst_cost))\n",
- " \n",
- " stats.append((tr_stats, valid_stats, (tst_cost, tst_accuracy)))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 2",
- "language": "python",
- "name": "python2"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 2
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.9"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/notebooks/05_Transfer_functions_solution.ipynb b/notebooks/05_Transfer_functions_solution.ipynb
deleted file mode 100644
index 1f6d7d8..0000000
--- a/notebooks/05_Transfer_functions_solution.ipynb
+++ /dev/null
@@ -1,708 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Introduction\n",
- "\n",
- "This tutorial focuses on implementation of alternatives to sigmoid transfer functions for hidden units. (*Transfer functions* are also called *activation functions* or *nonlinearities*.) First, we will work with hyperboilc tangent (tanh) and then unbounded (or partially unbounded) piecewise linear functions: Rectifying Linear Units (ReLU) and Maxout.\n",
- "\n",
- "\n",
- "## Virtual environments\n",
- "\n",
- "Before you proceed onwards, remember to activate your virtual environment by typing `activate_mlp` or `source ~/mlpractical/venv/bin/activate` (or if you did the original install the \"comfy way\" type: `workon mlpractical`).\n",
- "\n",
- "\n",
- "## Syncing the git repository\n",
- "\n",
- "Look here for more details. But in short, we recommend to create a separate branch for this lab, as follows:\n",
- "\n",
- "1. Enter the mlpractical directory `cd ~/mlpractical/repo-mlp`\n",
- "2. List the branches and check which are currently active by typing: `git branch`\n",
- "3. If you have followed our recommendations, you should be in the `lab4` branch, please commit your local changed to the repo index by typing:\n",
- "```\n",
- "git commit -am \"finished lab4\"\n",
- "```\n",
- "4. Now you can switch to `master` branch by typing: \n",
- "```\n",
- "git checkout master\n",
- " ```\n",
- "5. To update the repository (note, assuming master does not have any conflicts), if there are some, have a look here\n",
- "```\n",
- "git pull\n",
- "```\n",
- "6. And now, create the new branch & switch to it by typing:\n",
- "```\n",
- "git checkout -b lab5\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Overview of alternative transfer functions\n",
- "\n",
- "Now, we briefly summarise some other possible choices for hidden layer transfer functions.\n",
- "\n",
- "## Tanh\n",
- "\n",
- "Given a linear activation $a_{i}$ tanh implements the following operation:\n",
- "\n",
- "(1) $h_i(a_i) = \\mbox{tanh}(a_i) = \\frac{\\exp(a_i) - \\exp(-a_i)}{\\exp(a_i) + \\exp(-a_i)}$\n",
- "\n",
- "Hence, the derivative of $h_i$ with respect to $a_i$ is:\n",
- "\n",
- "(2) $\\begin{align}\n",
- "\\frac{\\partial h_i}{\\partial a_i} &= 1 - h^2_i\n",
- "\\end{align}\n",
- "$\n",
- "\n",
- "\n",
- "## ReLU\n",
- "\n",
- "Given a linear activation $a_{i}$ relu implements the following operation:\n",
- "\n",
- "(3) $h_i(a_i) = \\max(0, a_i)$\n",
- "\n",
- "Hence, the gradient is :\n",
- "\n",
- "(4) $\\begin{align}\n",
- "\\frac{\\partial h_i}{\\partial a_i} &=\n",
- "\\begin{cases}\n",
- " 1 & \\quad \\text{if } a_i > 0 \\\\\n",
- " 0 & \\quad \\text{if } a_i \\leq 0 \\\\\n",
- "\\end{cases}\n",
- "\\end{align}\n",
- "$\n",
- "\n",
- "ReLU implements a form of data-driven sparsity, that is, on average the activations are sparse (many of them are 0) but the general sparsity pattern will depend on particular data-point. This is different from sparsity obtained in model's parameters one can obtain with $L1$ regularisation as the latter affect all data-points in the same way.\n",
- "\n",
- "## Maxout\n",
- "\n",
- "Maxout is an example of data-driven type of non-linearity in which the transfer function can be learned from data. That is, the model can build a non-linear transfer function from piecewise linear components. These linear components, depending on the number of linear regions used in the pooling operator (given by parameter $K$), can approximate arbitrary functions, such as ReLU, abs, etc.\n",
- "\n",
- "Given some subset (group, pool) of $K$ linear activations $a_{j}, a_{j+1}, \\ldots, a_{j+K}$ at the $l$-th layer, maxout implements the following operation:\n",
- "\n",
- "(5) $h_i(a_j, a_{j+1}, \\ldots, a_{j+K}) = \\max(a_j, a_{j+1}, \\ldots, a_{j+K})$\n",
- "\n",
- "Hence, the gradient of $h_i$ w.r.t to the pooling region $a_{j}, a_{j+1}, \\ldots, a_{j+K}$ is :\n",
- "\n",
- "(6) $\\begin{align}\n",
- "\\frac{\\partial h_i}{\\partial (a_j, a_{j+1}, \\ldots, a_{j+K})} &=\n",
- "\\begin{cases}\n",
- " 1 & \\quad \\text{for the max activation} \\\\\n",
- " 0 & \\quad \\text{otherwise} \\\\\n",
- "\\end{cases}\n",
- "\\end{align}\n",
- "$\n",
- "\n",
- "Implementation tips are given in Exercise 3.\n",
- "\n",
- "# On weight initialisation\n",
- "\n",
- "Activation functions directly affect the \"network dynamics\", that is, the magnitudes of the statistics each layer is producing. For example, *slashing* non-linearities like sigmoid or tanh bring the linear activations to a certain bounded range. ReLU, on the contrary, has an unbounded positive side. This directly affects all statistics collected in forward and backward passes as well as the gradients w.r.t paramters - hence also the pace at which the model learns. That is why learning rate is usually required to be tuned for given the characterictics of the non-linearities used. \n",
- "\n",
- "Another important hyperparameter is the initial range used to initialise the weight matrices. We have largely ignored it so far (although if you did further experiments in coursework 1, you may have found setting it had an effect on training deeper networks with 4 or 5 hidden layers). However, for sigmoidal non-linearities (sigmoid, tanh) the initialisation range is an important hyperparameter and a considerable amount of research has been put into determining what is the best strategy for choosing it. In fact, one of the early triggers of the recent resurgence of deep learning was pre-training - techniques for initialising weights in an unsupervised manner so that one can effectively train deeper models in supervised fashion later. \n",
- "\n",
- "## Sigmoidal transfer functions\n",
- "\n",
- "Y. LeCun in [Efficient Backprop](http://link.springer.com/chapter/10.1007%2F3-540-49430-8_2) recommends the following setting of the initial range $r$ for sigmoidal units (assuming that the data has been normalised to zero mean, unit variance): \n",
- "\n",
- "(7) $ r = \\frac{1}{\\sqrt{N_{IN}}} $\n",
- "\n",
- "where $N_{IN}$ is the number of inputs to the given layer and the weights are then sampled from the (usually uniform) distribution $U(-r,r)$. The motivation is to keep the initial forward-pass signal in the linear region of the sigmoid non-linearity so that the gradients are large enough for training to proceed (note that the sigmoidal non-linearities saturate when activations are either very positive or very negative, leading to very small gradients and hence poor learning dynamics).\n",
- "\n",
- "The initialisation used in (7) however leads to different magnitudes of activations/gradients at different layers (due to multiplicative nature of the computations) and more recently, [Glorot et. al](http://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.pdf) proposed the so-called *normalised initialisation*, which ensures the variance of the forward signal (activations) is approximately the same in each layer. The same applies to the gradients obtained in backward pass. \n",
- "\n",
- "The $r$ in the *normalised initialisation* for $\\mbox{tanh}$ non-linearity is then:\n",
- "\n",
- "(8) $ r = \\frac{\\sqrt{6}}{\\sqrt{N_{IN}+N_{OUT}}} $\n",
- "\n",
- "For the sigmoid (logistic) non-linearity, to get similiar characteristics, one should scale $r$ in (8) by 4, that is:\n",
- "\n",
- "(9) $ r = \\frac{4\\sqrt{6}}{\\sqrt{N_{IN}+N_{OUT}}} $\n",
- "\n",
- "## Piece-wise linear transfer functions (ReLU, Maxout)\n",
- "\n",
- "For unbounded transfer functions initialisation is not as crucial as for sigmoidal ones. This is due to the fact that their gradients do not diminish (they are acutally more likely to explode) and they do not saturate (ReLU saturates at 0, but not on the positive slope, where gradient is 1 everywhere). (In practice ReLU is sometimes \"clipped\" with a maximum value, typically 20).\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Exercise 1: Implement the tanh transfer function\n",
- "\n",
- "Your implementation should follow the code conventions used to build other layer types (for example, Sigmoid and Softmax). Test your solution by training a one-hidden-layer model with 100 hidden units, similiar to the one used in Task 3a in the coursework. \n",
- "\n",
- "Tune the learning rate and compare the initial ranges in equations (7) and (8). Note that there might not be much difference for one-hidden-layer model, but you can easily notice a substantial gain from using (8) (or (9) for logistic sigmoid activation) for deeper models, for example, the 5 hidden-layer network from the first coursework.\n",
- "\n",
- "Implementation tip: Use numpy.tanh() to compute the non-linearity. Use the irange argument when creating the given layer type to provide the initial sampling range."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "INFO:root:Initialising data providers...\n"
- ]
- }
- ],
- "source": [
- "import numpy\n",
- "import logging\n",
- "from mlp.dataset import MNISTDataProvider\n",
- "\n",
- "logger = logging.getLogger()\n",
- "logger.setLevel(logging.INFO)\n",
- "\n",
- "# Note, you were asked to do run the experiments on all data and smaller models. \n",
- "# Here I am running the exercises on 1000 training data-points only (similar to regularisation notebook)\n",
- "logger.info('Initialising data providers...')\n",
- "train_dp = MNISTDataProvider(dset='train', batch_size=10, max_num_batches=100, randomize=True)\n",
- "valid_dp = MNISTDataProvider(dset='valid', batch_size=10000, max_num_batches=-10, randomize=False)\n",
- "test_dp = MNISTDataProvider(dset='eval', batch_size=10000, max_num_batches=-10, randomize=False)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {
- "collapsed": false,
- "scrolled": true
- },
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "INFO:root:Training started...\n",
- "INFO:mlp.optimisers:Epoch 0: Training cost (ce) for initial model is 2.319. Accuracy is 10.50%\n",
- "INFO:mlp.optimisers:Epoch 0: Validation cost (ce) for initial model is 2.315. Accuracy is 11.33%\n",
- "INFO:mlp.optimisers:Epoch 1: Training cost (ce) is 1.048. Accuracy is 66.30%\n",
- "INFO:mlp.optimisers:Epoch 1: Validation cost (ce) is 0.571. Accuracy is 82.72%\n",
- "INFO:mlp.optimisers:Epoch 1: Took 2 seconds. Training speed 764 pps. Validation speed 12988 pps.\n",
- "INFO:mlp.optimisers:Epoch 2: Training cost (ce) is 0.485. Accuracy is 84.40%\n",
- "INFO:mlp.optimisers:Epoch 2: Validation cost (ce) is 0.455. Accuracy is 86.58%\n",
- "INFO:mlp.optimisers:Epoch 2: Took 2 seconds. Training speed 720 pps. Validation speed 12988 pps.\n",
- "INFO:mlp.optimisers:Epoch 3: Training cost (ce) is 0.362. Accuracy is 87.70%\n",
- "INFO:mlp.optimisers:Epoch 3: Validation cost (ce) is 0.435. Accuracy is 86.90%\n",
- "INFO:mlp.optimisers:Epoch 3: Took 2 seconds. Training speed 788 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 4: Training cost (ce) is 0.251. Accuracy is 92.10%\n",
- "INFO:mlp.optimisers:Epoch 4: Validation cost (ce) is 0.417. Accuracy is 88.09%\n",
- "INFO:mlp.optimisers:Epoch 4: Took 2 seconds. Training speed 788 pps. Validation speed 13159 pps.\n",
- "INFO:mlp.optimisers:Epoch 5: Training cost (ce) is 0.175. Accuracy is 95.40%\n",
- "INFO:mlp.optimisers:Epoch 5: Validation cost (ce) is 0.405. Accuracy is 88.16%\n",
- "INFO:mlp.optimisers:Epoch 5: Took 2 seconds. Training speed 776 pps. Validation speed 12988 pps.\n",
- "INFO:mlp.optimisers:Epoch 6: Training cost (ce) is 0.121. Accuracy is 96.40%\n",
- "INFO:mlp.optimisers:Epoch 6: Validation cost (ce) is 0.458. Accuracy is 87.24%\n",
- "INFO:mlp.optimisers:Epoch 6: Took 2 seconds. Training speed 690 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 7: Training cost (ce) is 0.091. Accuracy is 97.90%\n",
- "INFO:mlp.optimisers:Epoch 7: Validation cost (ce) is 0.418. Accuracy is 88.37%\n",
- "INFO:mlp.optimisers:Epoch 7: Took 2 seconds. Training speed 841 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 8: Training cost (ce) is 0.065. Accuracy is 98.70%\n",
- "INFO:mlp.optimisers:Epoch 8: Validation cost (ce) is 0.400. Accuracy is 89.44%\n",
- "INFO:mlp.optimisers:Epoch 8: Took 2 seconds. Training speed 794 pps. Validation speed 12501 pps.\n",
- "INFO:mlp.optimisers:Epoch 9: Training cost (ce) is 0.043. Accuracy is 99.30%\n",
- "INFO:mlp.optimisers:Epoch 9: Validation cost (ce) is 0.406. Accuracy is 89.35%\n",
- "INFO:mlp.optimisers:Epoch 9: Took 2 seconds. Training speed 747 pps. Validation speed 12822 pps.\n",
- "INFO:mlp.optimisers:Epoch 10: Training cost (ce) is 0.029. Accuracy is 99.50%\n",
- "INFO:mlp.optimisers:Epoch 10: Validation cost (ce) is 0.410. Accuracy is 89.69%\n",
- "INFO:mlp.optimisers:Epoch 10: Took 2 seconds. Training speed 953 pps. Validation speed 12822 pps.\n",
- "INFO:mlp.optimisers:Epoch 11: Training cost (ce) is 0.023. Accuracy is 99.80%\n",
- "INFO:mlp.optimisers:Epoch 11: Validation cost (ce) is 0.424. Accuracy is 89.41%\n",
- "INFO:mlp.optimisers:Epoch 11: Took 2 seconds. Training speed 953 pps. Validation speed 13159 pps.\n",
- "INFO:mlp.optimisers:Epoch 12: Training cost (ce) is 0.018. Accuracy is 99.80%\n",
- "INFO:mlp.optimisers:Epoch 12: Validation cost (ce) is 0.429. Accuracy is 89.50%\n",
- "INFO:mlp.optimisers:Epoch 12: Took 2 seconds. Training speed 870 pps. Validation speed 12988 pps.\n",
- "INFO:mlp.optimisers:Epoch 13: Training cost (ce) is 0.015. Accuracy is 99.90%\n",
- "INFO:mlp.optimisers:Epoch 13: Validation cost (ce) is 0.428. Accuracy is 89.58%\n",
- "INFO:mlp.optimisers:Epoch 13: Took 2 seconds. Training speed 878 pps. Validation speed 12822 pps.\n",
- "INFO:mlp.optimisers:Epoch 14: Training cost (ce) is 0.012. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 14: Validation cost (ce) is 0.436. Accuracy is 89.41%\n",
- "INFO:mlp.optimisers:Epoch 14: Took 2 seconds. Training speed 894 pps. Validation speed 12501 pps.\n",
- "INFO:mlp.optimisers:Epoch 15: Training cost (ce) is 0.010. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 15: Validation cost (ce) is 0.433. Accuracy is 89.64%\n",
- "INFO:mlp.optimisers:Epoch 15: Took 2 seconds. Training speed 834 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 16: Training cost (ce) is 0.009. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 16: Validation cost (ce) is 0.439. Accuracy is 89.63%\n",
- "INFO:mlp.optimisers:Epoch 16: Took 2 seconds. Training speed 820 pps. Validation speed 12988 pps.\n",
- "INFO:mlp.optimisers:Epoch 17: Training cost (ce) is 0.008. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 17: Validation cost (ce) is 0.443. Accuracy is 89.78%\n",
- "INFO:mlp.optimisers:Epoch 17: Took 2 seconds. Training speed 902 pps. Validation speed 12501 pps.\n",
- "INFO:mlp.optimisers:Epoch 18: Training cost (ce) is 0.008. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 18: Validation cost (ce) is 0.446. Accuracy is 89.72%\n",
- "INFO:mlp.optimisers:Epoch 18: Took 2 seconds. Training speed 870 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 19: Training cost (ce) is 0.007. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 19: Validation cost (ce) is 0.445. Accuracy is 89.83%\n",
- "INFO:mlp.optimisers:Epoch 19: Took 2 seconds. Training speed 918 pps. Validation speed 12822 pps.\n",
- "INFO:mlp.optimisers:Epoch 20: Training cost (ce) is 0.007. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 20: Validation cost (ce) is 0.451. Accuracy is 89.75%\n",
- "INFO:mlp.optimisers:Epoch 20: Took 2 seconds. Training speed 834 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 21: Training cost (ce) is 0.006. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 21: Validation cost (ce) is 0.454. Accuracy is 89.80%\n",
- "INFO:mlp.optimisers:Epoch 21: Took 2 seconds. Training speed 902 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 22: Training cost (ce) is 0.006. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 22: Validation cost (ce) is 0.456. Accuracy is 89.77%\n",
- "INFO:mlp.optimisers:Epoch 22: Took 2 seconds. Training speed 863 pps. Validation speed 12501 pps.\n",
- "INFO:mlp.optimisers:Epoch 23: Training cost (ce) is 0.005. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 23: Validation cost (ce) is 0.458. Accuracy is 89.84%\n",
- "INFO:mlp.optimisers:Epoch 23: Took 2 seconds. Training speed 820 pps. Validation speed 12822 pps.\n",
- "INFO:mlp.optimisers:Epoch 24: Training cost (ce) is 0.005. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 24: Validation cost (ce) is 0.460. Accuracy is 89.80%\n",
- "INFO:mlp.optimisers:Epoch 24: Took 2 seconds. Training speed 856 pps. Validation speed 12988 pps.\n",
- "INFO:mlp.optimisers:Epoch 25: Training cost (ce) is 0.005. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 25: Validation cost (ce) is 0.461. Accuracy is 89.86%\n",
- "INFO:mlp.optimisers:Epoch 25: Took 2 seconds. Training speed 902 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 26: Training cost (ce) is 0.004. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 26: Validation cost (ce) is 0.467. Accuracy is 89.86%\n",
- "INFO:mlp.optimisers:Epoch 26: Took 2 seconds. Training speed 910 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 27: Training cost (ce) is 0.004. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 27: Validation cost (ce) is 0.466. Accuracy is 89.81%\n",
- "INFO:mlp.optimisers:Epoch 27: Took 2 seconds. Training speed 827 pps. Validation speed 12501 pps.\n",
- "INFO:mlp.optimisers:Epoch 28: Training cost (ce) is 0.004. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 28: Validation cost (ce) is 0.468. Accuracy is 89.84%\n",
- "INFO:mlp.optimisers:Epoch 28: Took 2 seconds. Training speed 894 pps. Validation speed 12501 pps.\n",
- "INFO:mlp.optimisers:Epoch 29: Training cost (ce) is 0.004. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 29: Validation cost (ce) is 0.471. Accuracy is 89.83%\n",
- "INFO:mlp.optimisers:Epoch 29: Took 2 seconds. Training speed 902 pps. Validation speed 12659 pps.\n",
- "INFO:mlp.optimisers:Epoch 30: Training cost (ce) is 0.004. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 30: Validation cost (ce) is 0.473. Accuracy is 89.81%\n",
- "INFO:mlp.optimisers:Epoch 30: Took 2 seconds. Training speed 918 pps. Validation speed 11495 pps.\n",
- "INFO:root:Testing the model on test set:\n",
- "INFO:root:MNIST test set accuracy is 89.33 %, cost (ce) is 0.480\n"
- ]
- }
- ],
- "source": [
- "\n",
- "from mlp.layers import MLP, Tanh, Softmax #import required layer types\n",
- "from mlp.optimisers import SGDOptimiser #import the optimiser\n",
- "from mlp.costs import CECost #import the cost we want to use for optimisation\n",
- "from mlp.schedulers import LearningRateFixed\n",
- "\n",
- "rng = numpy.random.RandomState([2015,10,10])\n",
- "\n",
- "#some hyper-parameters\n",
- "nhid = 100\n",
- "learning_rate = 0.2\n",
- "max_epochs = 30\n",
- "cost = CECost()\n",
- " \n",
- "stats = []\n",
- "for layer in xrange(1, 2):\n",
- "\n",
- " train_dp.reset()\n",
- " valid_dp.reset()\n",
- " test_dp.reset()\n",
- " \n",
- " #define the model\n",
- " model = MLP(cost=cost)\n",
- " model.add_layer(Tanh(idim=784, odim=nhid, irange=1./numpy.sqrt(784), rng=rng))\n",
- " for i in xrange(1, layer):\n",
- " logger.info(\"Stacking hidden layer (%s)\" % str(i+1))\n",
- " model.add_layer(Tanh(idim=nhid, odim=nhid, irange=0.2, rng=rng))\n",
- " model.add_layer(Softmax(idim=nhid, odim=10, rng=rng))\n",
- "\n",
- " # define the optimiser, here stochasitc gradient descent\n",
- " # with fixed learning rate and max_epochs\n",
- " lr_scheduler = LearningRateFixed(learning_rate=learning_rate, max_epochs=max_epochs)\n",
- " optimiser = SGDOptimiser(lr_scheduler=lr_scheduler)\n",
- "\n",
- " logger.info('Training started...')\n",
- " tr_stats, valid_stats = optimiser.train(model, train_dp, valid_dp)\n",
- "\n",
- " logger.info('Testing the model on test set:')\n",
- " tst_cost, tst_accuracy = optimiser.validate(model, test_dp)\n",
- " logger.info('MNIST test set accuracy is %.2f %%, cost (%s) is %.3f'%(tst_accuracy*100., cost.get_name(), tst_cost))\n",
- " \n",
- " stats.append((tr_stats, valid_stats, (tst_cost, tst_accuracy)))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Exercise 2: Implement ReLU\n",
- "\n",
- "Again, your implementation should follow the conventions used to build Linear, Sigmoid and Softmax layers. As in exercise 1, test your solution by training a one-hidden-layer model with 100 hidden units, similiar to the one used in Task 3a in the coursework. Tune the learning rate (start with the initial one set to 0.1) with the initial weight range set to 0.05."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "collapsed": false,
- "scrolled": true
- },
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "INFO:root:Training started...\n",
- "INFO:mlp.optimisers:Epoch 0: Training cost (ce) for initial model is 2.317. Accuracy is 15.20%\n",
- "INFO:mlp.optimisers:Epoch 0: Validation cost (ce) for initial model is 2.317. Accuracy is 13.98%\n",
- "INFO:mlp.optimisers:Epoch 1: Training cost (ce) is 1.400. Accuracy is 57.10%\n",
- "INFO:mlp.optimisers:Epoch 1: Validation cost (ce) is 0.666. Accuracy is 84.13%\n",
- "INFO:mlp.optimisers:Epoch 1: Took 0 seconds. Training speed 6600 pps. Validation speed 53922 pps.\n",
- "INFO:mlp.optimisers:Epoch 2: Training cost (ce) is 0.607. Accuracy is 82.20%\n",
- "INFO:mlp.optimisers:Epoch 2: Validation cost (ce) is 0.486. Accuracy is 85.70%\n",
- "INFO:mlp.optimisers:Epoch 2: Took 0 seconds. Training speed 3536 pps. Validation speed 80001 pps.\n",
- "INFO:mlp.optimisers:Epoch 3: Training cost (ce) is 0.413. Accuracy is 88.20%\n",
- "INFO:mlp.optimisers:Epoch 3: Validation cost (ce) is 0.427. Accuracy is 87.59%\n",
- "INFO:mlp.optimisers:Epoch 3: Took 0 seconds. Training speed 6251 pps. Validation speed 72222 pps.\n",
- "INFO:mlp.optimisers:Epoch 4: Training cost (ce) is 0.313. Accuracy is 90.30%\n",
- "INFO:mlp.optimisers:Epoch 4: Validation cost (ce) is 0.399. Accuracy is 88.12%\n",
- "INFO:mlp.optimisers:Epoch 4: Took 0 seconds. Training speed 5038 pps. Validation speed 65450 pps.\n",
- "INFO:mlp.optimisers:Epoch 5: Training cost (ce) is 0.233. Accuracy is 93.90%\n",
- "INFO:mlp.optimisers:Epoch 5: Validation cost (ce) is 0.370. Accuracy is 89.09%\n",
- "INFO:mlp.optimisers:Epoch 5: Took 0 seconds. Training speed 5425 pps. Validation speed 69818 pps.\n",
- "INFO:mlp.optimisers:Epoch 6: Training cost (ce) is 0.189. Accuracy is 94.90%\n",
- "INFO:mlp.optimisers:Epoch 6: Validation cost (ce) is 0.394. Accuracy is 88.26%\n",
- "INFO:mlp.optimisers:Epoch 6: Took 0 seconds. Training speed 5226 pps. Validation speed 73042 pps.\n",
- "INFO:mlp.optimisers:Epoch 7: Training cost (ce) is 0.141. Accuracy is 96.60%\n",
- "INFO:mlp.optimisers:Epoch 7: Validation cost (ce) is 0.386. Accuracy is 88.72%\n",
- "INFO:mlp.optimisers:Epoch 7: Took 0 seconds. Training speed 3155 pps. Validation speed 58826 pps.\n",
- "INFO:mlp.optimisers:Epoch 8: Training cost (ce) is 0.105. Accuracy is 98.50%\n",
- "INFO:mlp.optimisers:Epoch 8: Validation cost (ce) is 0.375. Accuracy is 89.52%\n",
- "INFO:mlp.optimisers:Epoch 8: Took 0 seconds. Training speed 5681 pps. Validation speed 72784 pps.\n",
- "INFO:mlp.optimisers:Epoch 9: Training cost (ce) is 0.084. Accuracy is 98.80%\n",
- "INFO:mlp.optimisers:Epoch 9: Validation cost (ce) is 0.385. Accuracy is 89.54%\n",
- "INFO:mlp.optimisers:Epoch 9: Took 0 seconds. Training speed 6656 pps. Validation speed 77418 pps.\n",
- "INFO:mlp.optimisers:Epoch 10: Training cost (ce) is 0.070. Accuracy is 98.70%\n",
- "INFO:mlp.optimisers:Epoch 10: Validation cost (ce) is 0.385. Accuracy is 89.74%\n",
- "INFO:mlp.optimisers:Epoch 10: Took 0 seconds. Training speed 7067 pps. Validation speed 76853 pps.\n",
- "INFO:mlp.optimisers:Epoch 11: Training cost (ce) is 0.051. Accuracy is 99.50%\n",
- "INFO:mlp.optimisers:Epoch 11: Validation cost (ce) is 0.411. Accuracy is 88.81%\n",
- "INFO:mlp.optimisers:Epoch 11: Took 0 seconds. Training speed 5863 pps. Validation speed 71343 pps.\n",
- "INFO:mlp.optimisers:Epoch 12: Training cost (ce) is 0.044. Accuracy is 99.50%\n",
- "INFO:mlp.optimisers:Epoch 12: Validation cost (ce) is 0.398. Accuracy is 89.34%\n",
- "INFO:mlp.optimisers:Epoch 12: Took 0 seconds. Training speed 5974 pps. Validation speed 64065 pps.\n",
- "INFO:mlp.optimisers:Epoch 13: Training cost (ce) is 0.035. Accuracy is 99.50%\n",
- "INFO:mlp.optimisers:Epoch 13: Validation cost (ce) is 0.400. Accuracy is 89.37%\n",
- "INFO:mlp.optimisers:Epoch 13: Took 0 seconds. Training speed 6211 pps. Validation speed 82847 pps.\n",
- "INFO:mlp.optimisers:Epoch 14: Training cost (ce) is 0.027. Accuracy is 99.70%\n",
- "INFO:mlp.optimisers:Epoch 14: Validation cost (ce) is 0.411. Accuracy is 89.30%\n",
- "INFO:mlp.optimisers:Epoch 14: Took 0 seconds. Training speed 5834 pps. Validation speed 68986 pps.\n",
- "INFO:mlp.optimisers:Epoch 15: Training cost (ce) is 0.023. Accuracy is 99.80%\n",
- "INFO:mlp.optimisers:Epoch 15: Validation cost (ce) is 0.398. Accuracy is 89.99%\n",
- "INFO:mlp.optimisers:Epoch 15: Took 0 seconds. Training speed 5601 pps. Validation speed 73777 pps.\n",
- "INFO:mlp.optimisers:Epoch 16: Training cost (ce) is 0.020. Accuracy is 99.80%\n",
- "INFO:mlp.optimisers:Epoch 16: Validation cost (ce) is 0.413. Accuracy is 89.64%\n",
- "INFO:mlp.optimisers:Epoch 16: Took 0 seconds. Training speed 6732 pps. Validation speed 62236 pps.\n",
- "INFO:mlp.optimisers:Epoch 17: Training cost (ce) is 0.017. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 17: Validation cost (ce) is 0.411. Accuracy is 89.74%\n",
- "INFO:mlp.optimisers:Epoch 17: Took 0 seconds. Training speed 5339 pps. Validation speed 70669 pps.\n",
- "INFO:mlp.optimisers:Epoch 18: Training cost (ce) is 0.016. Accuracy is 99.90%\n",
- "INFO:mlp.optimisers:Epoch 18: Validation cost (ce) is 0.414. Accuracy is 89.78%\n",
- "INFO:mlp.optimisers:Epoch 18: Took 0 seconds. Training speed 6595 pps. Validation speed 72214 pps.\n",
- "INFO:mlp.optimisers:Epoch 19: Training cost (ce) is 0.014. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 19: Validation cost (ce) is 0.418. Accuracy is 89.79%\n",
- "INFO:mlp.optimisers:Epoch 19: Took 0 seconds. Training speed 5860 pps. Validation speed 64213 pps.\n",
- "INFO:mlp.optimisers:Epoch 20: Training cost (ce) is 0.012. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 20: Validation cost (ce) is 0.418. Accuracy is 90.04%\n",
- "INFO:mlp.optimisers:Epoch 20: Took 0 seconds. Training speed 5726 pps. Validation speed 66591 pps.\n",
- "INFO:mlp.optimisers:Epoch 21: Training cost (ce) is 0.011. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 21: Validation cost (ce) is 0.422. Accuracy is 89.87%\n",
- "INFO:mlp.optimisers:Epoch 21: Took 0 seconds. Training speed 4780 pps. Validation speed 62159 pps.\n",
- "INFO:mlp.optimisers:Epoch 22: Training cost (ce) is 0.011. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 22: Validation cost (ce) is 0.425. Accuracy is 89.98%\n",
- "INFO:mlp.optimisers:Epoch 22: Took 0 seconds. Training speed 4839 pps. Validation speed 79642 pps.\n",
- "INFO:mlp.optimisers:Epoch 23: Training cost (ce) is 0.010. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 23: Validation cost (ce) is 0.425. Accuracy is 90.09%\n",
- "INFO:mlp.optimisers:Epoch 23: Took 0 seconds. Training speed 6742 pps. Validation speed 82643 pps.\n",
- "INFO:mlp.optimisers:Epoch 24: Training cost (ce) is 0.009. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 24: Validation cost (ce) is 0.429. Accuracy is 90.00%\n",
- "INFO:mlp.optimisers:Epoch 24: Took 0 seconds. Training speed 6590 pps. Validation speed 80128 pps.\n",
- "INFO:mlp.optimisers:Epoch 25: Training cost (ce) is 0.008. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 25: Validation cost (ce) is 0.432. Accuracy is 90.04%\n",
- "INFO:mlp.optimisers:Epoch 25: Took 0 seconds. Training speed 4635 pps. Validation speed 69917 pps.\n",
- "INFO:mlp.optimisers:Epoch 26: Training cost (ce) is 0.008. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 26: Validation cost (ce) is 0.435. Accuracy is 89.99%\n",
- "INFO:mlp.optimisers:Epoch 26: Took 0 seconds. Training speed 6685 pps. Validation speed 79693 pps.\n",
- "INFO:mlp.optimisers:Epoch 27: Training cost (ce) is 0.007. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 27: Validation cost (ce) is 0.437. Accuracy is 90.04%\n",
- "INFO:mlp.optimisers:Epoch 27: Took 0 seconds. Training speed 6992 pps. Validation speed 76700 pps.\n",
- "INFO:mlp.optimisers:Epoch 28: Training cost (ce) is 0.007. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 28: Validation cost (ce) is 0.438. Accuracy is 90.07%\n",
- "INFO:mlp.optimisers:Epoch 28: Took 0 seconds. Training speed 5097 pps. Validation speed 57735 pps.\n",
- "INFO:mlp.optimisers:Epoch 29: Training cost (ce) is 0.007. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 29: Validation cost (ce) is 0.440. Accuracy is 90.04%\n",
- "INFO:mlp.optimisers:Epoch 29: Took 0 seconds. Training speed 5390 pps. Validation speed 77974 pps.\n",
- "INFO:mlp.optimisers:Epoch 30: Training cost (ce) is 0.006. Accuracy is 100.00%\n",
- "INFO:mlp.optimisers:Epoch 30: Validation cost (ce) is 0.444. Accuracy is 90.08%\n",
- "INFO:mlp.optimisers:Epoch 30: Took 0 seconds. Training speed 5589 pps. Validation speed 60936 pps.\n",
- "INFO:root:Testing the model on test set:\n",
- "INFO:root:MNIST test set accuracy is 89.13 %, cost (ce) is 0.444\n"
- ]
- }
- ],
- "source": [
- "\n",
- "from mlp.layers import MLP, Relu, Softmax \n",
- "from mlp.optimisers import SGDOptimiser \n",
- "from mlp.costs import CECost \n",
- "from mlp.schedulers import LearningRateFixed\n",
- "\n",
- "rng = numpy.random.RandomState([2015,10,10])\n",
- "\n",
- "#some hyper-parameters\n",
- "nhid = 100\n",
- "learning_rate = 0.1\n",
- "max_epochs = 30\n",
- "cost = CECost()\n",
- " \n",
- "stats = []\n",
- "for layer in xrange(1, 2):\n",
- "\n",
- " train_dp.reset()\n",
- " valid_dp.reset()\n",
- " test_dp.reset()\n",
- " \n",
- " #define the model\n",
- " model = MLP(cost=cost)\n",
- " model.add_layer(Relu(idim=784, odim=nhid, irange=0.05, rng=rng))\n",
- " for i in xrange(1, layer):\n",
- " logger.info(\"Stacking hidden layer (%s)\" % str(i+1))\n",
- " model.add_layer(Relu(idim=nhid, odim=nhid, irange=0.2, rng=rng))\n",
- " model.add_layer(Softmax(idim=nhid, odim=10, rng=rng))\n",
- "\n",
- " # define the optimiser, here stochasitc gradient descent\n",
- " # with fixed learning rate and max_epochs\n",
- " lr_scheduler = LearningRateFixed(learning_rate=learning_rate, max_epochs=max_epochs)\n",
- " optimiser = SGDOptimiser(lr_scheduler=lr_scheduler)\n",
- "\n",
- " logger.info('Training started...')\n",
- " tr_stats, valid_stats = optimiser.train(model, train_dp, valid_dp)\n",
- "\n",
- " logger.info('Testing the model on test set:')\n",
- " tst_cost, tst_accuracy = optimiser.validate(model, test_dp)\n",
- " logger.info('MNIST test set accuracy is %.2f %%, cost (%s) is %.3f'%(tst_accuracy*100., cost.get_name(), tst_cost))\n",
- " \n",
- " stats.append((tr_stats, valid_stats, (tst_cost, tst_accuracy)))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Exercise 3: Implement Maxout\n",
- "\n",
- "As with the previous two exercises, your implementation should follow the conventions used to build the Linear, Sigmoid and Softmax layers. For now implement only non-overlapping pools (i.e. the pool in which all activations $a_{j}, a_{j+1}, \\ldots, a_{j+K}$ belong to only one pool). As before, test your solution by training a one-hidden-layer model with 100 hidden units, similiar to the one used in Task 3a in the coursework. Use the same optimisation hyper-parameters (learning rate, initial weights range) as you used for ReLU models. Tune the pool size $K$ (but keep the number of total parameters fixed).\n",
- "\n",
- "Note: The Max operator reduces dimensionality, hence for example, to get 100 hidden maxout units with pooling size set to $K=2$ the size of linear part needs to be set to $100K$ (assuming non-overlapping pools). This affects how you compute the total number of weights in the model.\n",
- "\n",
- "Implementation tips: To back-propagate through the maxout layer, one needs to keep track of which linear activation $a_{j}, a_{j+1}, \\ldots, a_{j+K}$ was the maximum in each pool. The convenient way to do so is by storing the indices of the maximum units in the fprop function and then in the backprop stage pass the gradient only through those (i.e. for example, one can build an auxiliary matrix where each element is either 1 (if unit was maximum, and passed forward through the max operator for a given data-point) or 0 otherwise. Then in the backward pass it suffices to upsample the maxout *igrads* signal to the linear layer dimension and element-wise multiply by the aforemenioned auxiliary matrix.\n",
- "\n",
- "*Optional:* Implement the generic pooling mechanism by introducing an additional *stride* hyper-parameter $0here for more details. But in short, we recommend to create a separate branch for the coursework, as follows:\n",
- "\n",
- "1. Enter the mlpractical directory `cd ~/mlpractical/repo-mlp`\n",
- "2. List the branches and check which are currently active by typing: `git branch`\n",
- "3. If you have followed our recommendations, you should be in the `lab5` branch, please commit your local changes to the repo index by typing:\n",
- "```\n",
- "git commit -am \"finished lab5\"\n",
- "```\n",
- "4. Now you can switch to `master` branch by typing: \n",
- "```\n",
- "git checkout master\n",
- " ```\n",
- "5. To update the repository (note, assuming master does not have any conflicts), if there are some, have a look here\n",
- "```\n",
- "git pull\n",
- "```\n",
- "6. And now, create the new branch & switch to it by typing:\n",
- "```\n",
- "git checkout -b coursework2\n",
- "```\n",
- "\n",
- "# Store the intermediate results (check-pointing and pickling)\n",
- "\n",
- "Once you have finished a task it is a good idea to check-point your current notebook's status (logs, plots and whatever else has been stored in the notebook). By doing this, you can always revert to this state later when necessary. You can do this by going to menus `File->Save and Checkpoint` and `File->Revert to Checkpoint`.\n",
- "\n",
- "Another good practice would be to save models and the statistics you generate to disk. You can easily do this in python by using *cPickle*, as in the following example."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "```python \n",
- "import cPickle\n",
- "\n",
- "#...\n",
- "(train_stats, valid_stats) = optimiser.train(model, train_dp, valid_dp)\n",
- "test_stats = optimiser.validate(model, test_dp)\n",
- "\n",
- "#this one saves the model, you can save like this any object \n",
- "#in python, like tuples, dictionaries, lists, etc.\n",
- "with open('task1_mdl.pkl','wb') as f:\n",
- " cPickle.dump(model, f)\n",
- " \n",
- "#then, to load you can type \n",
- "with open('task1_mdl.pkl','r') as f:\n",
- " model2 = cPickle.load(f)\n",
- "\n",
- "#and you can use it again (if needed) without retraining\n",
- "test_stats2 = optimiser.validate(model2, test_dp)\n",
- " \n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Notes on numpy and tensors\n",
- "\n",
- "This is a remainder on some numpy conventions you may find useful (especially in the second part of coursework #2, which involves the implementation of convolution and pooling layers).\n",
- "\n",
- "Links to numpy indexing:\n",
- "* [Numpy (advanced) indexing](http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)\n",
- "* [More on indexing of multi-dimensional arrays](http://docs.scipy.org/doc/numpy/user/basics.indexing.html)\n",
- "\n",
- "Below we list some (potentially) useful functions - you are not expected to need them all - we just outline some (non-obvious) functionality that you may find useful. Search the numpy documentation to get precise information about them. \n",
- "\n",
- "* `numpy.sum` - note that the axis arguments allow to specify a sequence of axes, hence, the reduction (here sum) can be performed along arbitrary dimensions.\n",
- "* `numpy.amax` - the same as with sum\n",
- "* `numpy.transpose` - can specify which axes you want to get transposed in a tensor\n",
- "* `numpy.argmax` - gives you the argument (index) of the maximum value in a tensor\n",
- "* `numpy.flatten` - collapses the n-dimensional tensor into vector (copy)\n",
- "* `numpy.ravel` - collapses the n-dimensional tensor into vector (creates a view)\n",
- "* `numpy.reshape` - allows to reshape a tensor into another (valid from data perspective) tensor (matrix, vector) with a different shape (but the same number of total elements)\n",
- "* `numpy.rot90(m, k)` - rotate matrix `m` by 90 degrees `k` times (counter-clockwise)\n",
- "* `numpy.newaxis` - add an axis with dimension 1 (handy for keeping tensor shapes compatible with expected broadcasting)\n",
- "* `numpy.rollaxis` - roll an axis in a tensor\n",
- "* `slice` - allows to specify a range (can be used when indexing numpy arrays)\n",
- "* `ellipsis` - allows to pick an arbitrary number of dimensions (inferred)\n",
- "* `max_and_argmax` - `(mlp.layers)` - an auxiliary function we have provided to get both max and argmax of a tensor across an arbitrary axes, possibly in the format preserving tensor's original shape (this is not trivial to do using numpy *out-of-the-shelf* functionality).\n",
- "\n",
- "The below cells contain some simple examples showing the basics of tensor manipulation in numpy (go through them if you haven't used numpy in this context before)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "%load_ext autoreload\n",
- "%load_ext cython\n",
- "\n",
- "from mlp.dataset import MNISTDataProvider\n",
- "import numpy\n",
- "\n",
- "rng = numpy.random.RandomState([2015, 11, 11])\n",
- "\n",
- "# we create MNISTDataProvider with 'conv_reshape' argument set to True, \n",
- "# this will give us a 4D tensor of shape\n",
- "# (batch_size, num_input_channels, width, height)\n",
- "# compared to standard fully connected one\n",
- "# (batch_size, width*height)\n",
- "batch_size = 2\n",
- "mdp = MNISTDataProvider('valid', batch_size=batch_size, max_num_batches=1, randomize=False, conv_reshape=True)\n",
- "x, t = mdp.next()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "%pylab\n",
- "%matplotlib inline\n",
- "# this will print (2, 1, 28, 28) which is\n",
- "# (batch_size, num_input_channels, width, height)\n",
- "print x.shape\n",
- "# and this the flattened version used to date (2, 784)\n",
- "print x.reshape(batch_size, -1).shape\n",
- "\n",
- "# you can pick the first image in the usual way you index numpy arrays\n",
- "img1 = x[0]\n",
- "# or in full notation which is equivalent (numpy by default treats single \n",
- "# indexes as selecting everything for this dimension)\n",
- "img2 = x[0, :, :, :]\n",
- "#this will be true\n",
- "print numpy.allclose(img1, img2)\n",
- "\n",
- "# Notice, slicing like this is collapsing the leading dimension \n",
- "# (as we picked only 0-th element), so the below will give you\n",
- "# (1, 28, 28)\n",
- "print img1.shape\n",
- "print img2.shape\n",
- "\n",
- "# to keep this dimension, one can use numpy.newaxis, which will add one dimension of\n",
- "# size 1, as a result you get a tensor (1, 1, 28, 28) \n",
- "# one image (as expected), but with preserved ndims of the source 4D tensor \n",
- "# this can be handy as it can simplify assignments to the original tensor\n",
- "img1=x[0, numpy.newaxis]\n",
- "print img1.shape\n",
- "\n",
- "#Let assume you want to get a sum of pixel intensities in each image in a mini-batch, \n",
- "#you can of course iterate over images and compute sum for each separately, but you can also:\n",
- "\n",
- "#to get the sum of pixel for each image separately, you could write:\n",
- "# (which means, sum along axis 2 and 3 together)\n",
- "print numpy.sum(x, axis=(2,3))\n",
- "\n",
- "#notice, that any of other calls would do what we want as:\n",
- "#will print the total sum for all images\n",
- "print numpy.sum(x)\n",
- "\n",
- "#will print the sum along the last axes (the columns of the images)\n",
- "print numpy.sum(x, axis=-1)\n",
- "\n",
- "# finally, let us swap the 10x20 rectangle of pixels between images\n",
- "# in numpy you can of course perform an arbitrary slicing and assignment\n",
- "# of sub-matrices\n",
- "\n",
- "slice_x = slice(10, 20)\n",
- "slice_y = slice(5, 25)\n",
- "\n",
- "patch1 = x[0, :, slice_x, slice_y]\n",
- "patch2 = x[1, :, slice_x, slice_y]\n",
- "print patch1.shape, patch1.shape\n",
- "\n",
- "xc = numpy.array(x) #this will make a copy of x\n",
- "xc[0, :, slice_x, slice_y] = patch2\n",
- "xc[1, :, slice_x, slice_y] = patch1\n",
- "\n",
- "fig, ax = plt.subplots(2,2)\n",
- "ax[0, 0].imshow(x[0,0], cmap=cm.Greys_r)\n",
- "ax[0, 1].imshow(x[1,0], cmap=cm.Greys_r)\n",
- "ax[1, 0].imshow(xc[0,0], cmap=cm.Greys_r)\n",
- "ax[1, 1].imshow(xc[1,0], cmap=cm.Greys_r)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Verifying the gradients\n",
- "\n",
- "One can numerically compute the gradient using the [finite differences](https://en.wikipedia.org/wiki/Finite_difference) method, that is, perturb the input arguments by some small value and then measure how this affects the function change:\n",
- "\n",
- "$\n",
- "f(x) = \\frac{f(x+\\epsilon) - f(x)}{\\epsilon}\n",
- "$\n",
- "\n",
- "Because $\\epsilon$ is usually very small (1e-4 or smaller) it is recommended (due to finite precision of numerical machines) to use the centred variant (which is implemented in mlp.utils):\n",
- "\n",
- "$\n",
- "f(x) = \\frac{f(x+\\epsilon) - f(x-\\epsilon)}{2\\epsilon}\n",
- "$\n",
- "\n",
- "The numerical gradient gives a good intuition if something is wrong. But take care, since one can easily find ill-conditioned cases where this test might fail - either due to numerical precision when gradients get really small, or other because of issues like discontinuities in transfer functions (ReLU, Maxout) where perturbing the inputs might cause the piecwise component to cross \"the border\". For instance, for ReLU assume $f(x) < 0$ by a some small margin in argument $x$ and the gradient is correctly set to 0. However, the finite difference quotient rule with some $\\epsilon$ such $f(x+\\epsilon) > 0$ will give a non-zero numerical gradient. Anyway, this method remains very useful in verifying whether the implemented forward and backward pasees are mutually correct.\n",
- "\n",
- "Below, you can find some examples on how one can use it, first for an arbitrary function and then short snippet on how to check the gradient backpropagated through layer."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "%autoreload\n",
- "\n",
- "import numpy\n",
- "from mlp.utils import verify_gradient\n",
- "\n",
- "rng = numpy.random.RandomState([2015, 11, 11])\n",
- "\n",
- "#simple example\n",
- "def f1_correct_grad(x, **kwargs):\n",
- " fval = x**2\n",
- " fgrad = 2*x\n",
- " return numpy.sum(fval), fgrad\n",
- "\n",
- "def f1_incorrect_grad(x, **kwargs):\n",
- " fval = x**2\n",
- " fgrad = x\n",
- " return numpy.sum(fval), fgrad\n",
- "\n",
- "x = rng.uniform(-5, 5, (10,))\n",
- "\n",
- "#this one should be OK\n",
- "print verify_gradient(f=f1_correct_grad, x=x)\n",
- "# this one should raise an exception, as the computed gradient is wrong\n",
- "print verify_gradient(f=f1_incorrect_grad, x=x)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can also check the backprop implementation in the layer. Notice, it **does not** necessarily check whether your layer implementation is correct but rather if the gradient computation is correct, given the forward pass computation. If you get the forward pass wrong, and somehow got the gradients right w.r.t what the forward pass is computing, the below check will not capture it (obviously). Contrary to normal scenraio where 32 floating point precision is sufficient, when checking gradients please make sure 64bit precision is used (or tune the tolerance)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "%autoreload\n",
- "\n",
- "from mlp.layers import Sigmoid\n",
- "from mlp.utils import verify_layer_gradient\n",
- "\n",
- "# keep it small, however, one can test it on some subset of MNIST\n",
- "idim = 10\n",
- "odim = 5\n",
- "\n",
- "x = rng.uniform(-2, 2, (20, idim))\n",
- "s = Sigmoid(idim=idim, odim=odim, rng=rng)\n",
- "verify_layer_gradient(s, x)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Speeding up the code\n",
- "\n",
- "Convolution can be accelerated in many ways, one of them is the use of *Cython* to write crucial bits in python (the one that involve heavy loop usage). You can speed up your code by:\n",
- "\n",
- "* Using numpy as much as possible (which will use highly optimised looping, and possibly a form of BLAS-implemented paralleism where possible)\n",
- "* Applying standard tricks to convolution (they boil down to more efficent use of BLAS routines (above) by loop unrolling - fewer operations on larger matrices, rather than more on smaller)\n",
- "* Speeding up the code by compiling pythonic c-functions (cython)\n",
- "\n",
- "\n",
- "## Using Cython for the crucial bottleneck pieces\n",
- "\n",
- "Cython will compile them to C and the code should be comparable in terms of efficiency to numpy using similar operations in numpy. Of course, one can only rely on numpy. Slicing numpy across many dimensions gets much more complicated than working with vectors and matrices and we do understand that this can be confusing. Hence, we allow the basic implementation (with any penalty or preference from our side) to be based on embedded loops (which is perhaps much easier to comprehend and debug).\n",
- "\n",
- "Below we give some example cython code for the matrix-matrix dot function from the second tutorial so that you can see the basic differences and compare the obtained speeds. They give you all the necessary patterns needed to implement naive (reasonably efficient) convolution. If you use native python, rather than Cython, then naive looping will be *very* slow.\n",
- "\n",
- "Some tutorials:\n",
- " * [Cython, language basics](http://docs.cython.org/src/userguide/language_basics.html#language-basics)\n",
- " * [Cython, basic tutorial](http://docs.cython.org/src/tutorial/cython_tutorial.html)\n",
- " * [Cython in ipython notebooks](http://docs.cython.org/src/quickstart/build.html)\n",
- " * [A tutorial on how to optimise the cython code](http://docs.cython.org/src/tutorial/numpy.html) (includes a working example which is actually simple convolution code, do not use it `as is`)\n",
- " \n",
- "\n",
- "Before you proceed, check that you have installed `cython` (it should be installed with scipy). If the below imports do not work, then - staying in the activated virtual environment - type:\n",
- " \n",
- " ```\n",
- " pip install cython\n",
- " ```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#native pythonic implementation (as in the second tutorial, rather slow...)\n",
- "def my_dot_mat_mat(x, W):\n",
- " I = x.shape[0]\n",
- " J = x.shape[1]\n",
- " K = W.shape[1]\n",
- " assert (J == W.shape[0]), (\n",
- " \"Number of columns in x expected to \"\n",
- " \" to be the same as rows in W, got\"\n",
- " \" %i != %i\" % (J, W.shape[0])\n",
- " )\n",
- " #allocate the output container\n",
- " y = numpy.zeros((I, K))\n",
- " \n",
- " #implement matrix-matrix inner product here\n",
- " for i in xrange(0, I):\n",
- " for k in xrange(0, K):\n",
- " for j in xrange(0, J):\n",
- " y[i, k] += x[i, j] * W[j,k]\n",
- " \n",
- " return y"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "%%cython\n",
- "# this shows an example on how to build cython accelerated\n",
- "# function than one can later use a standard python function\n",
- "\n",
- "#notice, you need to specify all the imports again (so they are\n",
- "#available in the compiled verions of the code, when executed)\n",
- "import numpy\n",
- "cimport numpy\n",
- "\n",
- "def my_dot_mat_mat_cython(numpy.ndarray x, numpy.ndarray W):\n",
- " cdef int I = x.shape[0]\n",
- " cdef int J = x.shape[1]\n",
- " cdef int K = W.shape[1]\n",
- " \n",
- " assert (J == W.shape[0]), (\n",
- " \"Number of columns in x expected to \"\n",
- " \" to be the same as rows in W, got\"\n",
- " \" %i != %i\" % (J, W.shape[0])\n",
- " )\n",
- " \n",
- " #allocate the output container and other variables\n",
- " cdef numpy.ndarray y = numpy.zeros((I, K))\n",
- " cdef int i, k, j\n",
- " \n",
- " #implement matrix-matrix inner product here\n",
- " for i in xrange(0, I):\n",
- " for k in xrange(0, K):\n",
- " for j in xrange(0, J):\n",
- " y[i, k] += x[i, j] * W[j,k]\n",
- " \n",
- " return y"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "%%cython\n",
- "# this shows an example on how to build cython accelerated\n",
- "# function than one can later call as usual from python\n",
- "\n",
- "#the optimisation relies on making an explicit c-buffers for data, \n",
- "#hence they can be accesses much quicker, notice, this is where \n",
- "#the real gain in speed comes from really\n",
- "\n",
- "#you need to specify all the imports again (so they are\n",
- "#available in the compiled verions of the code)\n",
- "import numpy\n",
- "cimport numpy\n",
- "\n",
- "#we specify the types our function is supposed to\n",
- "#be compiled with, float32 is sufficient for neural nets\n",
- "#you can use defalut 64bit precision if you want\n",
- "DTYPE = numpy.float32\n",
- "ctypedef numpy.float32_t DTYPE_t\n",
- "\n",
- "\n",
- "def my_dot_mat_mat_cython_optimised(numpy.ndarray[DTYPE_t, ndim=2] x, \n",
- " numpy.ndarray[DTYPE_t, ndim=2] W):\n",
- " \n",
- " cdef int I = x.shape[0]\n",
- " cdef int J = x.shape[1]\n",
- " cdef int K = W.shape[1]\n",
- " \n",
- " assert (J == W.shape[0]), (\n",
- " \"Number of columns in x expected to \"\n",
- " \" to be the same as rows in W, got\"\n",
- " \" %i != %i\" % (J, W.shape[0])\n",
- " )\n",
- " \n",
- " #allocate the output container and other variables, notice, when allocating\n",
- " #y we specify its type both for the buffer but also in numpy.zeros() function\n",
- " cdef numpy.ndarray[DTYPE_t, ndim=2] y = numpy.zeros((I, K), dtype=DTYPE)\n",
- " cdef int i, k, j\n",
- " \n",
- " #implement matrix-matrix inner product here\n",
- " for i in xrange(0, I):\n",
- " for k in xrange(0, K):\n",
- " for j in xrange(0, J):\n",
- " y[i, k] += x[i, j] * W[j,k]\n",
- " \n",
- " return y"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can optimise the code further as in the [linked](http://docs.cython.org/src/tutorial/numpy.html) tutorial. However, the above example seems to be a reasonable compromise for developing the code - it gives reasonably accelerated code, with all the checks one may expect to be existent under development (checking bounds of indices, wheter types of variables match, tracking overflows etc.). Look [here](http://docs.cython.org/src/reference/compilation.html) for more optimisation decorators that one can use to speed things up.\n",
- "\n",
- "Below we do some benchmarks on each of the above functions. Notice the huge speed-up in going from non-optimised cython code to an optimised one (on my machine, 643ms -> 6.35ms - this is 2 orders of magnitude!). It is still around two times slower than the BLAS accelerated numpy.dot routine (the non-cached result is around 3.3ms). But our method just benchmarks the dot product, an operation that has been optimised incredibly well in numerical libraries. Of course, we **do not** want you to use this code for dot products and you should rely on functions provided by numpy (whenever reasonably possible). The above code was just given as an example how to produce much more efficient code with very small effort. In many scenarios (convolution is an example) the code is more complex than a single dot product and some looping is necessary anyway, especially when dealing with multi-dimensional tensors where atomic operations using direct loop-based indexing may be much easier to comprehend (and debug) than a direct multi-dimensional manipulation of numpy tensors."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#generate bit bigger matrices, to better evaluate timings\n",
- "\n",
- "# note, we explicitly cast them to float32 as it was the type cython\n",
- "# functions were compiled with, float32 is more than sufficient precision\n",
- "# for neural networks\n",
- "x = rng.uniform(-1, 1, (10, 1000)).astype(numpy.float32)\n",
- "W = rng.uniform(-0.3, 0.2, (1000, 100)).astype(numpy.float32)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "print 'native pyton my_dot timings:'\n",
- "%timeit -n10 my_dot_mat_mat(x, W)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "print 'cython my_dot timings:'\n",
- "%timeit -n10 my_dot_mat_mat_cython(x, W)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "print 'optimised cython my_dot timings:'\n",
- "%timeit -n10 my_dot_mat_mat_cython_optimised(x, W)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "print 'numpy.dot timings (with BLAS):'\n",
- "%timeit -n10 numpy.dot(x, W)"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 2",
- "language": "python",
- "name": "python2"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 2
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.10"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/notebooks/07_MLP_Coursework2.ipynb b/notebooks/07_MLP_Coursework2.ipynb
deleted file mode 100644
index d772972..0000000
--- a/notebooks/07_MLP_Coursework2.ipynb
+++ /dev/null
@@ -1,362 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "**Please don't edit this cell!**\n",
- "\n",
- "# Marks and Feedback\n",
- "\n",
- "**Total Marks:** XX/100\n",
- "\n",
- "**Overall comments:**\n",
- "\n",
- "\n",
- "## Part 1. Investigations into Neural Networks (35 marks)\n",
- "\n",
- "* **Task 1**: *Experiments with learning rate schedules* - XX/5\n",
- " * learning rate schedulers implemented\n",
- " * experiments carried out\n",
- " * further comments\n",
- "\n",
- "\n",
- "* **Task 2**: *Experiments with regularisation* - XX/5\n",
- " * L1 experiments\n",
- " * L2 experiments\n",
- " * dropout experiments\n",
- " * annealed dropout implmented\n",
- " * further experiments carried out\n",
- " * further comments\n",
- " \n",
- "\n",
- "* **Task 3**: *Experiments with pretraining* - XX/15\n",
- " * autoencoder pretraining implemented\n",
- " * denoising autoencoder pretraining implemented\n",
- " * CE layer-by-layer pretraining implemented\n",
- " * experiments\n",
- " * further comments\n",
- "\n",
- "\n",
- "* **Task 4**: *Experiments with data augmentation* - XX/5\n",
- " * training data augmneted using noise, rotation, ...\n",
- " * any further augmnetations\n",
- " * experiments \n",
- " * further comments\n",
- "\n",
- "\n",
- "* **Task 5**: *State of the art* - XX/5\n",
- " * motivation for systems constructed\n",
- " * experiments\n",
- " * accuracy of best system\n",
- " * further comments\n",
- "\n",
- "\n",
- "\n",
- "## Part 2. Convolutional Neural Networks (55 marks)\n",
- "\n",
- "* **Task 6**: *Implement convolutional layer* - XX/20\n",
- " * linear conv layer\n",
- " * sigmoid conv layer\n",
- " * relu conv layer\n",
- " * any checks for correctness\n",
- " * loop-based or vectorised implementations\n",
- " * timing comparisons\n",
- "\n",
- "\n",
- "* **Task 7**: *Implement maxpooling layer* - XX/10\n",
- " * implementation of non-overlapping pooling\n",
- " * generic implementation\n",
- " * any checks for correctness\n",
- "\n",
- "\n",
- "* **Task 8**: *Experiments with convolutional networks* - XX/25\n",
- " * 1 conv layer (1 fmap)\n",
- " * 1 conv layer (5 fmaps)\n",
- " * 2 conv layers\n",
- " * further experiments\n",
- "\n",
- "\n",
- "\n",
- "## Presentation (10 marks)\n",
- "\n",
- "* ** Marks:** XX/10\n",
- " * Concise description of each system constructed\n",
- " * Experiment design and motivations for different systems\n",
- " * Presentation of results - graphs, tables, diagrams\n",
- " * Conclusions\n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Coursework #2\n",
- "\n",
- "## Introduction\n",
- "\n",
- "\n",
- "## Previous Tutorials\n",
- "\n",
- "Before starting this coursework make sure that you have completed the following labs:\n",
- "\n",
- "* [04_Regularisation.ipynb](https://github.com/CSTR-Edinburgh/mlpractical/blob/master/04_Regularisation.ipynb) - regularising the model\n",
- "* [05_Transfer_functions.ipynb](https://github.com/CSTR-Edinburgh/mlpractical/blob/master/05_Transfer_functions.ipynb) - building and training different activation functions\n",
- "* [06_MLP_Coursework2_Introduction.ipynb](https://github.com/CSTR-Edinburgh/mlpractical/blob/master/06_MLP_Coursework2_Introduction.ipynb) - Notes on numpy and tensors\n",
- "\n",
- "\n",
- "## Submission\n",
- "**Submission Deadline: Thursday 14 January 2016, 16:00** \n",
- "\n",
- "Submit the coursework as an ipython notebook file, using the `submit` command in the terminal on a DICE machine. If your file is `06_MLP_Coursework1.ipynb` then you would enter:\n",
- "\n",
- "`submit mlp 2 06_MLP_Coursework1.ipynb` \n",
- "\n",
- "where `mlp 2` indicates this is the second coursework of MLP.\n",
- "\n",
- "After submitting, you should receive an email of acknowledgment from the system confirming that your submission has been received successfully. Keep the email as evidence of your coursework submission.\n",
- "\n",
- "**Please make sure you submit a single `ipynb` file (and nothing else)!**\n",
- "\n",
- "**Submission Deadline: Thursday 14 January 2016, 16:00** \n",
- "\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Getting Started\n",
- "Please enter your student number and the date in the next code cell."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "#MLP Coursework 2\n",
- "#Student number: \n",
- "#Date: "
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Part 1. Investigations into Neural Networks (35 marks)\n",
- "\n",
- "In this part you are may choose exactly what you implement. However, you are expected to express your motivations, observations, and findings in a clear and cohesive way. Try to make it clear why you decided to do certain things. Use graphs and/or tables of results to show trends and other characteristics you think are important. \n",
- "\n",
- "For example, in Task 1 you could experiment with different schedulers in order to compare their convergence properties. In Task 2 you could look into (and visualise) what happens to weights when applying L1 and/or L2 regularisation when training. For instance, you could create sorted histograms of weight magnitudes in in each layer, etc..\n",
- "\n",
- "**Before submission, please collapse all the log entries into smaller boxes (by clicking on the bar on the left hand side)**\n",
- "\n",
- "### Task 1 - Experiments with learning rate schedules (5 marks)\n",
- "\n",
- "Investigate the effect of learning rate schedules on training and accuracy. Implement at least one additional learning rate scheduler mentioned in the lectures. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "#load the corresponding code here, and also attach scripts that run the experiments ()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Task 2 - Experiments with regularisers (5 marks)\n",
- "\n",
- "Investigate the effect of different regularisation approaches (L1, L2, dropout). Implement the annealing dropout scheduler (mentioned in lecture 5). Do some further investigations and experiments with model structures (and regularisers) of your choice. "
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Task 3 - Experiments with pretraining (15 marks)\n",
- "\n",
- "Implement pretraining of multi-layer networks with autoencoders, denoising autoencoders, and using layer-by-layer cross-entropy training. \n",
- "\n",
- "Implementation tip: You could add the corresponding methods to `optimiser`, namely, `pretrain()` and `pretrain_epoch()`, for autoencoders. Simiilarly, `pretrain_discriminative()` and `pretrain_epoch_discriminative()` for cross-entropy layer-by-layer pretraining. Of course, you can modify any other necessary pieces, but include all the modified fragments below."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Task 4 - Experiments with data augmentation (5 marks)\n",
- "\n",
- "Using the standard MNIST training data, generate some augmented training examples (for example, using noise or rotation). Perform experiments on using this expanded training data."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Task 5 - State of the art (5 marks)\n",
- "\n",
- "Using any techniques you have learnt so far (combining any number of them), build and train the best model you can (no other constraints)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "collapsed": true
- },
- "source": [
- "# Part 2. Convolutional Neural Networks (55 marks)\n",
- "\n",
- "In this part of the coursework, you are required to implement deep convolutional networks. This includes code for forward prop, back prop, and weight updates for convolutional and max-pooling layers, and should support the stacking of convolutional + pooling layers. You should implement all the parts relating to the convolutional layer in the mlp/conv.py module; if you decide to implement some routines in cython, keep them in mlp/conv.pyx). Attach both files in this notebook.\n",
- "\n",
- "Implementation tips: Look at [lecture 7](http://www.inf.ed.ac.uk/teaching/courses/mlp/2015/mlp07-cnn.pdf) and [lecture 8](http://www.inf.ed.ac.uk/teaching/courses/mlp/2015/mlp08-cnn2.pdf), and the introductory tutorial, [06_MLP_Coursework2_Introduction.ipynb](https://github.com/CSTR-Edinburgh/mlpractical/blob/master/06_MLP_Coursework2_Introduction.ipynb)\n",
- "\n",
- "### Task 6 - Implement convolutional layer (20 marks)\n",
- "\n",
- "Implement linear convolutional layer, and then extend to sigmoid and ReLU transfer functions (do it in a similar way to fully-connected layers). Include all relevant code. It is recommended that you first implement in the naive way with nested loops (python and/or cython); optionally you may then implement in a vectorised way in numpy. Include logs for each way you implement the convolutional layer, as timings for different implementations are of interest. Include all relevant code."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "collapsed": true
- },
- "source": [
- "### Task 7 - Implement max-pooling layer (10 marks)\n",
- "\n",
- "Implement a max-pooling layer. Non-overlapping pooling (which was assumed in the lecture presentation) is required. You may also implement a more generic solution with striding as well. Include all relevant code."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Task 8 - Experiments with convolutional networks (25 marks)\n",
- "\n",
- "Construct convolutional networks with a softmax output layer and a single fully connected hidden layer. Your first experiments should use one convolutional+pooling layer. As a default use convolutional kernels of dimension 5x5 (stride 1) and pooling regions of 2x2 (stride 2, hence non-overlapping).\n",
- "\n",
- "* Implement and test a convolutional network with 1 feature map\n",
- "* Implement and test a convolutional network with 5 feature maps\n",
- "\n",
- "Explore convolutional networks with two convolutional layers, by implementing, training, and evaluating a network with two convolutional+maxpooling layers with 5 feature maps in the first convolutional layer, and 10 feature maps in the second convolutional layer.\n",
- "\n",
- "Carry out further experiments to optimise the convolutional network architecture (you could explore kernel sizes and strides, number of feature maps, sizes and strides of pooling operator, etc. - it is up to you)."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "collapsed": true
- },
- "source": [
- "**This is the end of coursework 2.**\n",
- "\n",
- "Please remember to save your notebook, and submit your notebook following the instructions at the top. Please make sure that you have executed all the code cells when you submit the notebook.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": []
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 2",
- "language": "python",
- "name": "python2"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 2
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython2",
- "version": "2.7.10"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}