diff --git a/notebooks/00_Introduction.ipynb b/notebooks/00_Introduction.ipynb index 925f7ce..f545f95 100644 --- a/notebooks/00_Introduction.ipynb +++ b/notebooks/00_Introduction.ipynb @@ -2,175 +2,299 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "nbpresent": { + "id": "b167e6e2-05e0-4a4b-a6cc-47cab1c728b4" + } + }, "source": [ "# Introduction\n", "\n", - "This notebook shows how to set-up a working python envirnoment for the Machine Learning Practical course.\n", + "## Getting started with Jupyter notebooks\n", "\n", + "The majority of your work in this course will be done using Jupyter notebooks so we will here introduce some of the basics of the notebook system. If you are already comfortable using notebooks or just would rather get on with some coding feel free to [skip straight to the exercises below](#Exercises).\n", "\n", - "# Setting up the software\n", + "### Jupyter basics: the server, dashboard and kernels\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", + "In launching this notebook you will have already come across two of the other key components of the Jupyter system - the notebook *server* and *dashboard* interface.\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", + "We began by starting a notebook server instance in the terminal by running\n", "\n", "```\n", - "export MLP_WDIR=~/mlpractical\n", + "jupyter notebook\n", "```\n", "\n", - "Now re-source `~/.bashrc` by typing (so the env variables get updated!): `source ~/.bashrc`\n", + "This will have begun printing a series of log messages to terminal output similar to\n", "\n", - "Enter the `repos-3rd` directory by typing: `cd ~/mlpractical/repos-3rd` (or ```cd $MLP_WDIR/repos-3rd``` if you want)\n", + "```\n", + "$ jupyter notebook\n", + "[I 08:58:24.417 NotebookApp] Serving notebooks from local directory: ~/mlpractical\n", + "[I 08:58:24.417 NotebookApp] 0 active kernels\n", + "[I 08:58:24.417 NotebookApp] The Jupyter Notebook is running at: http://localhost:8888/\n", + "```\n", "\n", - "### Configuring virtual environment\n", + "The last message included here indicates the URL the application is being served at. The default behaviour of the `jupyter notebook` command is to open a tab in a web browser pointing to this address after the server has started up. The server can be launched without opening a browser window by running `jupyter notebook --no-browser`. This can be useful for example when running a notebook server on a remote machine over SSH. Descriptions of various other command options can be found by displaying the command help page using\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", + "juptyer notebook --help\n", + "```\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", + "While the notebook server is running it will continue printing log messages to terminal it was started from. Unless you detach the process from the terminal session you will need to keep the session open to keep the notebook server alive. If you want to close down a running server instance from the terminal you can use `Ctrl+C` - this will bring up a confirmation message asking you to confirm you wish to shut the server down. You can either enter `y` or skip the confirmation by hitting `Ctrl+C` again.\n", + "\n", + "When the notebook application first opens in your browser you are taken to the notebook *dashboard*. This will appear something like this\n", + "\n", + "\n", + "\n", + "The dashboard above is showing the `Files` tab, a list of files in the directory the notebook server was launched from. We can navigate in to a sub-directory by clicking on a directory name and back up to the parent directory by clicking the `..` link. An important point to note is that the top-most level that you will be able to navigate to is the directory you run the server from. This is a security feature and generally you should try to limit the access the server has by launching it in the highest level directory which gives you access to all the files you need to work with.\n", + "\n", + "As well as allowing you to launch existing notebooks, the `Files` tab of the dashboard also allows new notebooks to be created using the `New` drop-down on the right. It can also perform basic file-management tasks such as renaming and deleting files (select a file by checking the box alongside it to bring up a context menu toolbar).\n", + "\n", + "In addition to opening notebook files, we can also edit text files such as `.py` source files, directly in the browser by opening them from the dashboard. The in-built text-editor is less-featured than a full IDE but is useful for quick edits of source files and previewing data files.\n", + "\n", + "The `Running` tab of the dashboard gives a list of the currently running notebook instances. This can be useful to keep track of which notebooks are still running and to shutdown (or reopen) old notebook processes when the corresponding tab has been closed. In Jupyter parlance, the Python process associated with a notebook is often termed a *kernel* although this is also sometimes used to refer to a slightly different [concept](http://jupyter.readthedocs.io/en/latest/projects/kernels.html).\n", + "\n", + "### The notebook interface\n", + "\n", + "The top of your notebook window should appear something like this:\n", + "\n", + "\n", + "\n", + "The name of the current notebook is displayed at the top of the page and can be edited by clicking on the text of the name. Displayed alongside this is an indication of the last manual *checkpoint* of the notebook file. On-going changes are auto-saved at regular intervals; the check-point mechanism is mainly meant as a way to recover an earlier version of a notebook after making unwanted changes. Note the default system only currently supports storing a single previous checkpoint despite the `Revert to checkpoint` dropdown under the `File` menu perhaps suggesting otherwise.\n", + "\n", + "As well as having options to save and revert to checkpoints, the `File` menu also allows new notebooks to be created in same directory as the current notebook, a copy of the current notebook to be made and the ability to export the current notebook to various formats.\n", + "\n", + "The `Edit` menu contains standard clipboard functions as well as options for reorganising notebook *cells*. Cells are the basic units of notebooks, and can contain formatted text like the one you are reading at the moment or runnable code as we will see below. The `Edit` and `Insert` drop down menus offer various options for moving cells around the notebook, merging and splitting cells and inserting new ones, while the `Cell` menu allow running of code cells and changing cell types.\n", + "\n", + "The `Kernel` menu offers some useful commands for managing the Python process (kernel) running in the notebook. In particular it provides options for interrupting a busy kernel (useful for example if you realise you have set a slow code cell running with incorrect parameters) and to restart the current kernel. This will cause all variables currently defined in the workspace to be lost but may be necessary to get the kernel back to a consistent state after polluting the namespace with lots of global variables or when trying to run code from an updated module and `reload` is failing to work. \n", + "\n", + "To the far right of the menu toolbar is a kernel status indicator. When a dark filled circle is shown this means the kernel is currently busy and any further code cell run commands will be queued to happen after the currently running cell has completed. An open status circle indicates the kernel is currently idle.\n", + "\n", + "The final row of the top notebook interface is the notebook toolbar which contains shortcut buttons to some common commands such as clipboard actions and cell / kernel management. If you are interested in learning more about the notebook user interface you may wish to run through the `User Interface Tour` under the `Help` menu drop down.\n", + "\n", + "### Markdown cells: easy text formatting\n", + "\n", + "This entire introduction has been written in what is termed a *Markdown* cell of a notebook. [Markdown](https://en.wikipedia.org/wiki/Markdown) is a lightweight markup language intended to be readable in plain-text. As you may wish to use Markdown cells to keep your own formatted notes in notebooks, a small sampling of the formatting syntax available is below (escaped mark-up on top and corresponding rendered output below that); there are many much more extensive syntax guides - for example [this cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).\n", + "\n", + "---\n", + "\n", + "```\n", + "## Level 2 heading\n", + "### Level 3 heading\n", + "\n", + "*Italicised* and **bold** text.\n", + "\n", + " * bulleted\n", + " * lists\n", " \n", - " ```alias activate_mlp=\"source $MLP_WDIR/venv/bin/activate\"```\n", + "and\n", + "\n", + " 1. enumerated\n", + " 2. lists\n", + "\n", + "Inline maths $y = mx + c$ using [MathJax](https://www.mathjax.org/) as well as display style\n", + "\n", + "$$ ax^2 + bx + c = 0 \\qquad \\Rightarrow \\qquad x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a} $$\n", + "```\n", + "---\n", + "\n", + "## Level 2 heading\n", + "### Level 3 heading\n", + "\n", + "*Italicised* and **bold** text.\n", + "\n", + " * bulleted\n", + " * lists\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", + "and\n", "\n", - "### Installing remaining packages\n", + " 1. enumerated\n", + " 2. lists\n", "\n", - "Then, before you follow next, install/upgrade the following packages:\n", + "Inline maths $y = mx + c$ using [MathJax]() as well as display maths\n", "\n", + "$$ ax^2 + bx + c = 0 \\qquad \\Rightarrow \\qquad x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a} $$\n", + "\n", + "---\n", + "\n", + "We can also directly use HTML tags in Markdown cells to embed rich content such as images and videos.\n", + "\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", + "---\n", "\n", - "### Installing numpy\n", + "\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", "\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", + "### Code cells: in browser code execution\n", "\n", - "```\n", - "export OMP_NUM_THREADS=1\n", - "```\n", + "Up to now we have not seen any runnable code. An example of a executable code cell is below. To run it first click on the cell so that it is highlighted, then either click the button on the notebook toolbar, go to `Cell > Run Cells` or use the keyboard shortcut `Ctrl+Enter`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello world!\n", + "Hello again!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Alarming hello!\n" + ] + }, + { + "data": { + "text/plain": [ + "'And again!'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from __future__ import print_function\n", + "import sys\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", + "print('Hello world!')\n", + "print('Alarming hello!', file=sys.stderr)\n", + "print('Hello again!')\n", + "'And again!'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example shows the three main components of a code cell.\n", "\n", - "#### OpenBlas\n", + "The most obvious is the input area. This (unsuprisingly) is used to enter the code to be run which will be automatically syntax highlighted.\n", "\n", - "Enter again repos-3rd directory and copy into terminal the following commands (one at the time):\n", + "To the immediate left of the input area is the execution indicator / counter. Before a code cell is first run this will display `In [ ]:`. After the cell is run this is updated to `In [n]:` where `n` is a number corresponding to the current execution counter which is incremented whenever any code cell in the notebook is run. This can therefore be used to keep track of the relative order in which cells were last run. There is no fundamental requirement to run cells in the order they are organised in the notebook, though things will usually be more readable if you keep things in roughly in order!\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", + "Immediately below the input area is the output area. This shows any output produced by the code in the cell. This is dealt with a little bit confusingly in the current Jupyter version. At the top any output to [`stdout`](https://en.wikipedia.org/wiki/Standard_streams#Standard_output_.28stdout.29) is displayed. Immediately below that output to [`stderr`](https://en.wikipedia.org/wiki/Standard_streams#Standard_error_.28stderr.29) is displayed. All of the output to `stdout` is displayed together even if there has been output to `stderr` between as shown by the suprising ordering in the output here. \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", + "The final part of the output area is the *display* area. By default this will just display the returned output of the last Python statement as would usually be the case in a (I)Python interpreter run in a terminal. What is displayed for a particular object is by default determined by its special `__repr__` method e.g. for a string it is just the quote enclosed value of the string itself.\n", "\n", - "```\n", - "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MLP_WDIR/repos-3rd/OpenBLAS/lib\n", - "```\n", + "### Useful keyboard shortcuts\n", "\n", - "Note, we again are using MLP_WDIR here, so the above line needs to be placed after you set MLP_WDIR.\n", + "There are a wealth of keyboard shortcuts available in the notebook interface. For an exhaustive list see the `Keyboard Shortcuts` option under the `Help` menu. We will cover a few of those we find most useful below.\n", "\n", - "After you have edited `.bashrc` run\n", + "Shortcuts come in two flavours: those applicable in *command mode*, active when no cell is currently being edited and indicated by a blue highlight around the current cell; those applicable in *edit mode* when the content of a cell is being edited, indicated by a green current cell highlight.\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", + "In edit mode of a code cell, two of the more generically useful keyboard shortcuts are offered by the `Tab` key.\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", + " * Pressing `Tab` a single time while editing code will bring up suggested completions of what you have typed so far. This is done in a scope aware manner so for example typing `a` + `[Tab]` in a code cell will come up with a list of objects beginning with `a` in the current global namespace, while typing `np.a` + `[Tab]` (assuming `import numpy as np` has been run already) will bring up a list of objects in the root NumPy namespace beginning with `a`.\n", + " * Pressing `Shift+Tab` once immediately after opening parenthesis of a function or method will cause a tool-tip to appear with the function signature (including argument names and defaults) and its docstring. Pressing `Shift+Tab` twice in succession will cause an expanded version of the same tooltip to appear, useful for longer docstrings. Pressing `Shift+Tab` four times in succession will cause the information to be instead displayed in a pager docked to bottom of the notebook interface which stays attached even when making further edits to the code cell and so can be useful for keeping documentation visible when editing e.g. to help remember the name of arguments to a function and their purposes.\n", "\n", - "#### Numpy\n", + "A series of useful shortcuts available in both command and edit mode are `[modifier]+Enter` where `[modifier]` is one of `Ctrl` (run selected cell), `Shift` (run selected cell and select next) or `Alt` (run selected cell and insert a new cell after).\n", "\n", - "To install `numpy` linked against the OpenBLAS libraries we just compiled, first run the following commands (one at a time)\n", + "A useful command mode shortcut to know about is the ability to toggle line numbers on and off for a cell by pressing `L` which can be useful when trying to diagnose stack traces printed when an exception is raised or when referring someone else to a section of code.\n", + " \n", + "### Extensions and magics\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", + " * Extensions and magics\n", + " * %%timeit, time, debug, pdb, precision\n", + " \n", + "### Plotting with `matplotlib`\n", "\n", - "Assuming the virtual environment is activated, the below command will install numpy in a desired space (`~/mlpractical/venv/...`):\n", + "When setting up your environment one of the dependencies we asked you to install was `matplotlib`. This is an extensive plotting and data visualisation library which is tightly integrated with NumPy and Jupyter notebooks." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "nbpresent": { + "id": "2bced39d-ae3a-4603-ac94-fbb6a6283a96" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsIAAAF/CAYAAABDrq/vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCCGEEMKV/g/9AdlDBfWSkwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# use the matplotlib magic to specify to display plots inline in the notebook\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", "\n", - "```\n", - "python setup.py install\n", - "```\n", + "# generate a pair of sinusoids\n", + "x = np.linspace(0., 2. * np.pi, 100)\n", + "y1 = np.sin(x)\n", + "y2 = np.cos(x)\n", "\n", - "Now use pip to install remaining packages: `scipy`, `matplotlib`, `argparse`, and `nose` by executing:\n", + "# produce a new figure object with a defined (width, height) in inches\n", + "fig = plt.figure(figsize=(8, 4))\n", + "# add a single axis to the figure\n", + "ax = fig.add_subplot(111)\n", + "# plot the two sinusoidal traces on the axis, adjusting the line width\n", + "# and adding LaTeX legend labels\n", + "ax.plot(x, y1, linewidth=2, label=r'$\\sin(x)$')\n", + "ax.plot(x, y2, linewidth=2, label=r'$\\cos(x)$')\n", + "# set the axis labels\n", + "ax.set_xlabel('$x$', fontsize=16)\n", + "ax.set_ylabel('$y$', fontsize=16)\n", + "# force the legend to be displayed\n", + "ax.legend()\n", + "# adjust the limits of the horizontal axis\n", + "ax.set_xlim(0., 2. * np.pi)\n", + "# make a grid be displayed in the axis background\n", + "ax.grid('on')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbpresent": { + "id": "533c10f0-95ba-4684-a72d-fd52cef0d007" + } + }, + "source": [ + "# Exercises\n", "\n", - "```\n", - "pip install scipy matplotlib argparse nose\n", - "```\n", + "Today's exercises are meant to allow you to get some initial familiarisation with the `mlp` package and how data is provided to the learning functions. Next week onwards, we will follow with the material covered in lectures.\n", "\n", - "### Getting the mlpractical repository\n", + "## Data providers\n", "\n", - "Clone the course repository from the github, by navigating to `~/mlpractical` directory and typing:\n", + "Open (in the browser) the [`mlp.data_providers`](../../edit/mlp/data_providers.py) module. Have a look through the code and comments, then follow to the exercises.\n", "\n", - "```\n", - "cd $MLP_WDIR\n", - "git clone https://github.com/CSTR-Edinburgh/mlpractical.git repo-mlp\n", - "```\n", + "### Exercise 1 \n", "\n", - "When download is ready, enter the repo-mlp directory and start the actual interactive notebook session by typing:\n", + " * Using MNISTDataProvider, write code that iterates over the first 5 minibatches of size 100 data-points. \n", + " * Display each batch of MNIST digits in a 10x10 grid of images. \n", + " \n", + "**Notes**:\n", "\n", - "```\n", - "cd repo-mlp\n", - "ipython notebook\n", - "```\n", + " * Images are returned from the provider as tuples of numpy arrays `(inputs, targets)`. The `inputs` matrix has shape `(batch_size, input_dim)` while the `targets` array is of shape `(batch_size,)`, where `batch_size` is the number of data points in a single batch and `input_dim` is dimensionality of the input features. \n", + " * Each input data-point (image) is stored as a 784 dimensional vector of pixel intensities normalised to $[0, 1]$ from inital integer values in $[0, 255]$. However, the original spatial domain is two dimensional, so before plotting you will need to reshape the one dimensional input arrays in to two dimensional arrays 2D (MNIST images have the same height and width dimensions).\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." + "*Tip:* Some potentially useful functions for this exercise are: `np.reshape`, `plt.imshow`, `subplot`, `gridspec`" ] }, { @@ -178,119 +302,16 @@ "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": null, - "metadata": { - "collapsed": false + "nbpresent": { + "id": "113d1e72-6a3a-424b-bafb-9148a1ee21ca" + } }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import matplotlib.gridspec as gridspec\n", "import matplotlib.cm as cm\n", - "from mlp.dataset import MNISTDataProvider\n", + "from mlp.data_providers import MNISTDataProvider\n", "\n", "def show_mnist_image(img):\n", " fig = plt.figure()\n", @@ -300,14 +321,17 @@ " plt.show()\n", "\n", "def show_mnist_images(batch):\n", - " raise NotImplementedError('Write me!')\n" + " raise NotImplementedError('Write me!')" ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false + "collapsed": false, + "nbpresent": { + "id": "978c1095-a9ce-4626-a113-e0be5fe51ecb" + } }, "outputs": [], "source": [ @@ -321,7 +345,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "nbpresent": { + "id": "d2d525de-5d5b-41d5-b2fb-a83874dba986" + } + }, "source": [ "### Exercise 2\n", "\n", @@ -337,7 +365,10 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": false + "collapsed": false, + "nbpresent": { + "id": "5e437105-a6d4-4187-9557-26e7296e9909" + } }, "outputs": [], "source": [ @@ -348,7 +379,10 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": true + "collapsed": true, + "nbpresent": { + "id": "0e6d7154-d799-428a-bf1f-f574351ed649" + } }, "outputs": [], "source": [] @@ -356,7 +390,10 @@ { "cell_type": "markdown", "metadata": { - "collapsed": true + "collapsed": true, + "nbpresent": { + "id": "471093b7-4b94-4295-823a-5285c79d3119" + } }, "source": [ "### Exercise 3\n", @@ -370,7 +407,10 @@ "cell_type": "code", "execution_count": null, "metadata": { - "collapsed": true + "collapsed": true, + "nbpresent": { + "id": "c8553a56-9f25-4198-8a1a-d7e9572b4382" + } }, "outputs": [], "source": [] @@ -378,7 +418,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "Python [default]", "language": "python", "name": "python2" }, @@ -392,7 +432,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", - "version": "2.7.9" + "version": "2.7.12" } }, "nbformat": 4,