{ "metadata": { "name": "" }, "nbformat": 3, "nbformat_minor": 0, "worksheets": [ { "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Tutorial Overview\n", "\n", "The goal of this tutorial is to introduce the MKS while advancing our knowledge of scientific Python.\n", "\n", "The tutorial consists of 6 notebooks.\n", "\n", " - Introduce scientific computing with Python\n", " - introduces the most basic concepts\n", " - for those who really have no Python exposure\n", " - doesn't require participation\n", " \n", " - Introduce MKS\n", " - basic equations \n", " - MKS in real space\n", " - MKS in Fourier space\n", " - test\n", " \n", " - Simple 1D filter\n", " - simple example\n", " - demonstrate the importance of removing redundancies\n", " \n", " - Cross-validation\n", " - introduce MKSRegressionClass\n", " - how to cross-validate using Scikit-learn\n", " \n", " - Scaling coefficients\n", " - how to scale up influence coefficients\n", " \n", " - Improve performance, optimize the MKS to do a full Cahn-Hilliard simulation\n", " - use `numexper`, `pyfftw`, parallel IPython\n", "\n", "To start:\n", "\n", "```\n", "$ git clone https://github.com/wd15/pymks\n", "$ cd ~/pymks/notebooks\n", "$ ipython notebook\n", "```\n", " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Git" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Check your version of the `pymks` repository. Should be the same as mine" ] }, { "cell_type": "code", "collapsed": false, "input": [ "!git log -1" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "\u001b[33mcommit bb64ae063b79a73093e77eac624101f3a364c499\u001b[m\r\n", "Author: Daniel Wheeler \r\n", "Date: Sun Jan 12 21:26:10 2014 -0500\r\n", "\r\n", " Finshed exercises and solutions.\r\n", " \r\n", " Fix #31\r\n" ] } ], "prompt_number": 88 }, { "cell_type": "markdown", "metadata": {}, "source": [ "if not, do the following" ] }, { "cell_type": "code", "collapsed": false, "input": [ "!git pull origin master" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "X11 forwarding request failed on channel 0\r", "\r\n" ] }, { "output_type": "stream", "stream": "stdout", "text": [ "From github.com:wd15/pymks\r\n", " * branch master -> FETCH_HEAD\r\n" ] }, { "output_type": "stream", "stream": "stdout", "text": [ "Already up-to-date.\r\n" ] } ], "prompt_number": 89 }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can now branch the working copy to make your own changes" ] }, { "cell_type": "code", "collapsed": false, "input": [ "!git checkout -b my_branch" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "code", "collapsed": false, "input": [ "!git branch" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Issues" ] }, { "cell_type": "code", "collapsed": false, "input": [ "Use the issue tracker" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Test your installation" ] }, { "cell_type": "code", "collapsed": false, "input": [ "%matplotlib inline\n", "%load_ext autoreload\n", "%autoreload 2\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import fipy as fp\n", "import pymks\n", "import sklearn\n", "import numexpr\n", "import line_profiler\n", "import pyfftw\n", "\n", "pymks.test()\n", "plt.plot(np.sin(np.linspace(0, 2 * np.pi, 1000)))" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "The autoreload extension is already loaded. To reload it, use:\n", " %reload_ext autoreload\n" ] }, { "metadata": {}, "output_type": "pyout", "prompt_number": 90, "text": [ "[]" ] }, { "metadata": {}, "output_type": "display_data", "png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAD7CAYAAACCEpQdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", "text": [ "" ] } ], "prompt_number": 90 }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Scientific computing in Python\n", "\n", "A gentle introduction to scientific computing with Python.\n", "\n", " - Python data structures\n", " - Numpy\n", " - IPython notebook" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Python Data Structures\n", "\n", "Python has 4 important container types, lists, tuples, dictionaries and sets." ] }, { "cell_type": "code", "collapsed": false, "input": [ "my_list = ['a', 1, 2, 1.1, 'a']\n", "type(my_list)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 91, "text": [ "list" ] } ], "prompt_number": 91 }, { "cell_type": "code", "collapsed": false, "input": [ "my_tuple = ('a', 1, 2, 1.1, 'a')\n", "type(my_tuple)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 92, "text": [ "tuple" ] } ], "prompt_number": 92 }, { "cell_type": "code", "collapsed": false, "input": [ "my_dict = {'a': 'a', 'b' : 1, 1 : 2, 2.1 : 1.1, 'e' : 'a'}\n", "type(my_dict)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 93, "text": [ "dict" ] } ], "prompt_number": 93 }, { "cell_type": "code", "collapsed": false, "input": [ "my_set = set(my_list)\n", "print my_set\n", "type(my_set)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "set(['a', 1, 2, 1.1])\n" ] }, { "metadata": {}, "output_type": "pyout", "prompt_number": 94, "text": [ "set" ] } ], "prompt_number": 94 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lists are mutable" ] }, { "cell_type": "code", "collapsed": false, "input": [ "my_list[1] = 2\n", "my_list" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 95, "text": [ "['a', 2, 2, 1.1, 'a']" ] } ], "prompt_number": 95 }, { "cell_type": "markdown", "metadata": {}, "source": [ "and can be generated with \"list comprehensions\"" ] }, { "cell_type": "code", "collapsed": false, "input": [ "[i**2 for i in range(4)]" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 96, "text": [ "[0, 1, 4, 9]" ] } ], "prompt_number": 96 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Tuples are immutable (unchangable)" ] }, { "cell_type": "code", "collapsed": false, "input": [ "my_tuple[1] = 2" ], "language": "python", "metadata": {}, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dictionaries map keys to values and support item assignment. They are [hash tables](http://en.wikipedia.org/wiki/Hash_table). Hash table look up is independent of the number of `key:value` pairs. `key` must be something hashable." ] }, { "cell_type": "code", "collapsed": false, "input": [ "print my_dict" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "{'a': 'a', 1: 2, 2.1: 1.1, 'b': 1, 'e': 'a'}\n" ] } ], "prompt_number": 97 }, { "cell_type": "markdown", "metadata": {}, "source": [ "only immutable objects can be hashed" ] }, { "cell_type": "code", "collapsed": false, "input": [ "{[1] : 'a'}" ], "language": "python", "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "unhashable type: 'list'", "output_type": "pyerr", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;33m{\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m:\u001b[0m \u001b[1;34m'a'\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'list'" ] } ], "prompt_number": 98 }, { "cell_type": "code", "collapsed": false, "input": [ "{(1, 2) : 'b'}" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 99, "text": [ "{(1, 2): 'b'}" ] } ], "prompt_number": 99 }, { "cell_type": "code", "collapsed": false, "input": [ "my_dict['key'] = 'item'\n", "del my_dict['a']\n", "print my_dict" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "{1: 2, 'b': 1, 'e': 'a', 2.1: 1.1, 'key': 'item'}\n" ] } ], "prompt_number": 100 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Python References and Assignments" ] }, { "cell_type": "code", "collapsed": false, "input": [ "x = [1, 2, 3]\n", "y = x\n", "print x\n", "print y" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[1, 2, 3]\n", "[1, 2, 3]\n" ] } ], "prompt_number": 101 }, { "cell_type": "code", "collapsed": false, "input": [ "x[2] = 4\n", "\n", "print x\n", "print y" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[1, 2, 4]\n", "[1, 2, 4]\n" ] } ], "prompt_number": 102 }, { "cell_type": "code", "collapsed": false, "input": [ "class A:\n", " pass\n", "\n", "x = A()\n", "y = x\n", "print x\n", "print y" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "<__main__.A instance at 0x191fd3b0>\n", "<__main__.A instance at 0x191fd3b0>\n" ] } ], "prompt_number": 103 }, { "cell_type": "code", "collapsed": false, "input": [ "x = A()\n", "\n", "print x\n", "print y" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "<__main__.A instance at 0x191fdb90>\n", "<__main__.A instance at 0x191fd3b0>\n" ] } ], "prompt_number": 104 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Numpy\n", "\n", "Why do we need Numpy if we already have lists and tuples?" ] }, { "cell_type": "code", "collapsed": false, "input": [ "np.array((0., 1, 2, 3, 1.1))" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 105, "text": [ "array([ 0. , 1. , 2. , 3. , 1.1])" ] } ], "prompt_number": 105 }, { "cell_type": "code", "collapsed": false, "input": [ "np.array((0, 1, 2, 2, 1)).dtype\n" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 107, "text": [ "dtype('int64')" ] } ], "prompt_number": 107 }, { "cell_type": "code", "collapsed": false, "input": [ "N = 100000\n", "a = [1., 0.2] * N\n", "b = [0.5, 0.4] * N\n", "print a[:10]\n", "print b[:10]" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2, 1.0, 0.2]\n", "[0.5, 0.4, 0.5, 0.4, 0.5, 0.4, 0.5, 0.4, 0.5, 0.4]\n" ] } ], "prompt_number": 108 }, { "cell_type": "code", "collapsed": false, "input": [ "def multiply(a, b):\n", " for i in xrange(len(a)):\n", " c = a[i] * b[i]\n", "\n", "%timeit multiply(a, b)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "100 loops, best of 3: 16 ms per loop\n" ] } ], "prompt_number": 109 }, { "cell_type": "code", "collapsed": false, "input": [ "import numpy as np\n", "\n", "a = np.array(a)\n", "b = np.array(b)\n", "\n", "%timeit c = a * b" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "1000 loops, best of 3: 224 \u00b5s per loop\n" ] } ], "prompt_number": 110 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Vector operations are more succinct\n", "\n", "```python\n", "c = a * b\n", "```\n", "\n", "beats\n", "\n", "```python\n", "for i in xrange(len(c)):\n", " c[i] = a[i] * b[i]\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numpy indexing tricks" ] }, { "cell_type": "code", "collapsed": false, "input": [ "a = np.arange(10)**3\n", "print a\n", "print a[2]\n", "print a[2:5]" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[ 0 1 8 27 64 125 216 343 512 729]\n", "8\n", "[ 8 27 64]\n" ] } ], "prompt_number": 111 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Fancy assignment" ] }, { "cell_type": "code", "collapsed": false, "input": [ "a[:6:2] = 1000.\n", "print a" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[1000 1 1000 27 1000 125 216 343 512 729]\n" ] } ], "prompt_number": 112 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Reverse an array" ] }, { "cell_type": "code", "collapsed": false, "input": [ "print a[::-1]" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[ 729 512 343 216 125 1000 27 1000 1 1000]\n" ] } ], "prompt_number": 113 }, { "cell_type": "markdown", "metadata": {}, "source": [ "See http://wiki.scipy.org/Tentative_NumPy_Tutorial for more indexing and reshaping tricks." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## IPython Notebook\n", "\n", " - web-based interactive computational environment\n", "\n", " - exectute code in other interpreters and port output into python\n", " \n", " - parallel and distributed computing\n", " \n", " - rich media, maths" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Execute code from other interpreters" ] }, { "cell_type": "code", "collapsed": false, "input": [ "%%bash --out cpuinfo\n", "\n", "cat /proc/cpuinfo | grep processor" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 114 }, { "cell_type": "code", "collapsed": false, "input": [ "print cpuinfo\n", "Nproc = len(cpuinfo.splitlines())\n", "print Nproc" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "processor\t: 0\n", "processor\t: 1\n", "processor\t: 2\n", "processor\t: 3\n", "processor\t: 4\n", "processor\t: 5\n", "processor\t: 6\n", "processor\t: 7\n", "\n", "8\n" ] } ], "prompt_number": 115 }, { "cell_type": "code", "collapsed": false, "input": [ "%%bash --out notebooks\n", "\n", "ls -al | grep [^\\ ].ipynb" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 116 }, { "cell_type": "code", "collapsed": false, "input": [ "print notebooks" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "-rw-r--r-- 1 wd15 machine 2961 Jan 13 08:47 00 - Workshop Overview.ipynb\n", "-rw-r--r-- 1 wd15 machine 38458 Jan 13 14:35 01 - Python Intro.ipynb\n", "-rw-r--r-- 1 wd15 machine 20758 Jan 12 17:07 02 - MKS Intro.ipynb\n", "-rw-r--r-- 1 wd15 machine 9922 Jan 12 22:25 03 - Simple Filter.ipynb\n", "-rw-r--r-- 1 wd15 machine 14630 Jan 12 21:25 04 - Cross Validation.ipynb\n", "-rw-r--r-- 1 wd15 machine 7641 Jan 12 17:07 05 - Scaling Coefficients.ipynb\n", "-rw-r--r-- 1 wd15 machine 22817 Jan 12 21:24 06 - Improving Performance.ipynb\n", "-rw-r--r-- 1 wd15 machine 1707 Jan 13 08:51 reproducible_research_talk.ipynb\n", "-rw-r--r-- 1 wd15 machine 28177972 Jan 3 17:06 sandbox.ipynb\n", "-rw-r--r-- 1 wd15 machine 6746 Jan 12 21:25 Solutions.ipynb\n", "\n" ] } ], "prompt_number": 117 }, { "cell_type": "code", "collapsed": false, "input": [ "sorted(notebooks.splitlines(), key=lambda k: int(k.split()[4]))[::-1]" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 118, "text": [ "['-rw-r--r-- 1 wd15 machine 28177972 Jan 3 17:06 sandbox.ipynb',\n", " '-rw-r--r-- 1 wd15 machine 38458 Jan 13 14:35 01 - Python Intro.ipynb',\n", " '-rw-r--r-- 1 wd15 machine 22817 Jan 12 21:24 06 - Improving Performance.ipynb',\n", " '-rw-r--r-- 1 wd15 machine 20758 Jan 12 17:07 02 - MKS Intro.ipynb',\n", " '-rw-r--r-- 1 wd15 machine 14630 Jan 12 21:25 04 - Cross Validation.ipynb',\n", " '-rw-r--r-- 1 wd15 machine 9922 Jan 12 22:25 03 - Simple Filter.ipynb',\n", " '-rw-r--r-- 1 wd15 machine 7641 Jan 12 17:07 05 - Scaling Coefficients.ipynb',\n", " '-rw-r--r-- 1 wd15 machine 6746 Jan 12 21:25 Solutions.ipynb',\n", " '-rw-r--r-- 1 wd15 machine 2961 Jan 13 08:47 00 - Workshop Overview.ipynb',\n", " '-rw-r--r-- 1 wd15 machine 1707 Jan 13 08:51 reproducible_research_talk.ipynb']" ] } ], "prompt_number": 118 }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `%%script` cell magic lets you run a cell in a subprocess of any interpreter on your system, such as: bash, ruby, perl, zsh, R, etc." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using the IPython Notebook rather than the command line for common tasks encourages better record keeping." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Parallel IPython.\n", "\n", "Start up parallel engines\n", "\n", " $ ipcluster start -n 8\n", "\n", "Create a `Client`." ] }, { "cell_type": "code", "collapsed": false, "input": [ "from IPython.parallel import Client\n", "engines = Client()\n", "engines" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 119, "text": [ "" ] } ], "prompt_number": 119 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Make a \"direct view\" of the engines" ] }, { "cell_type": "code", "collapsed": false, "input": [ "dview = engines[:]\n", "print \"engines IDs\",engines.ids\n", "dview.block = True\n", "dview.activate()" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "engines IDs [0, 1, 2, 3, 4, 5, 6, 7]\n" ] } ], "prompt_number": 120 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Calculate eigenvalues for lots of small arrays." ] }, { "cell_type": "code", "collapsed": false, "input": [ "N = 1000\n", "M = 4\n", "np.random.seed(201)\n", "A = np.random.random((N, M, M))\n", "Evec = np.zeros((N, M), dtype=complex)\n", "print type(A)\n", "print A.dtype\n", "print A.shape" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "\n", "float64\n", "(1000, 4, 4)\n" ] } ], "prompt_number": 121 }, { "cell_type": "code", "collapsed": false, "input": [ "?np.linalg.eig" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 122 }, { "cell_type": "markdown", "metadata": {}, "source": [ "`eig` calculates eigenvalues and eigenvectors, $A v_i = \\lambda_i v_i$" ] }, { "cell_type": "code", "collapsed": false, "input": [ "np.linalg.eig([[1, 0], [0, 0.5]])" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 123, "text": [ "(array([ 1. , 0.5]), array([[ 1., 0.],\n", " [ 0., 1.]]))" ] } ], "prompt_number": 123 }, { "cell_type": "code", "collapsed": false, "input": [ "for i in xrange(N):\n", " Evec[i] = np.linalg.eig(A[i])[0]" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 124 }, { "cell_type": "markdown", "metadata": {}, "source": [ "This can be written in one line of code." ] }, { "cell_type": "code", "collapsed": false, "input": [ "Evec_zip = np.array(zip(*map(np.linalg.eig, A))[0])" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 125 }, { "cell_type": "code", "collapsed": false, "input": [ "print np.allclose(Evec_zip, Evec)" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "True\n" ] } ], "prompt_number": 126 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's try this in parallel. First, place parts of `A` on each of the engines." ] }, { "cell_type": "code", "collapsed": false, "input": [ "dview.scatter('A', A)" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 127 }, { "cell_type": "markdown", "metadata": {}, "source": [ "How has `A` been partitioned?" ] }, { "cell_type": "code", "collapsed": false, "input": [ "for a in dview['A']:\n", " print a.shape" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "(125, 4, 4)\n", "(125, 4, 4)\n", "(125, 4, 4)\n", "(125, 4, 4)\n", "(125, 4, 4)\n", "(125, 4, 4)\n", "(125, 4, 4)\n", "(125, 4, 4)\n" ] } ], "prompt_number": 128 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Do the parallel calculation." ] }, { "cell_type": "code", "collapsed": false, "input": [ "?px" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 129 }, { "cell_type": "code", "collapsed": false, "input": [ "%px import numpy as np" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 130 }, { "cell_type": "code", "collapsed": false, "input": [ "%px Evec = np.array(zip(*map(np.linalg.eig, A))[0])" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 131 }, { "cell_type": "code", "collapsed": false, "input": [ "%px print Evec.shape" ], "language": "python", "metadata": {}, "outputs": [ { "output_type": "stream", "stream": "stdout", "text": [ "[stdout:0] (125, 4)\n", "[stdout:1] (125, 4)\n", "[stdout:2] (125, 4)\n", "[stdout:3] (125, 4)\n", "[stdout:4] (125, 4)\n", "[stdout:5] (125, 4)\n", "[stdout:6] (125, 4)\n", "[stdout:7] (125, 4)\n" ] } ], "prompt_number": 132 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Gather the result." ] }, { "cell_type": "code", "collapsed": false, "input": [ "Evec_parallel = dview.gather('Evec')" ], "language": "python", "metadata": {}, "outputs": [], "prompt_number": 133 }, { "cell_type": "code", "collapsed": false, "input": [ "Evec_parallel.shape" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 134, "text": [ "(1000, 4)" ] } ], "prompt_number": 134 }, { "cell_type": "markdown", "metadata": {}, "source": [ "Check that it worked." ] }, { "cell_type": "code", "collapsed": false, "input": [ "np.allclose(Evec, Evec_parallel)" ], "language": "python", "metadata": {}, "outputs": [ { "metadata": {}, "output_type": "pyout", "prompt_number": 135, "text": [ "True" ] } ], "prompt_number": 135 }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercise 01-0\n", "\n", "Use an alternative method for the `np.array(zip(*map(np.linalg.eig, A))[0])` code fragment. Try using a list comprehension `[i for i in range(4)]` along with `np.concatenate` and `np.reshape`.\n", "\n", "Use `%timeit` to compare the calculation speeds in serial, parallel and for different numbers of engines.\n", "\n", " - compare the calculation speeds for different numbers of engines\n", " - `dview = engines[:Neng]` creates views on different numbers of engines\n", " - remember to set the view to block `dview.block = True`. What happens if `dview.block = False`?\n", " - remember to activate the view so that `%px` knows which view to use (`dview.activate()`).\n", "\n", "if done, capture the output with `%%capture out`, parse the output, and then plot the time versus number of engines." ] } ], "metadata": {} } ] }