Updated notebooks, ready to be presented in slideshow mode

02_1_Indexing and Slicing.ipynb

@@ -13,7 +13,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### Setting up the data"
    ]
@@ -426,7 +430,7 @@
    "cell_type": "markdown",
    "metadata": {
     "slideshow": {
-     "slide_type": "-"
+     "slide_type": "subslide"
     }
    },
    "source": [
@@ -818,7 +822,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Fancy indexing is the name for when an array or list is used in-place of an index: "
    ]
@@ -896,7 +904,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "-"
+     "slide_type": "subslide"
     }
    },
    "outputs": [
@@ -944,7 +952,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* Alternatively:"
    ]
@@ -993,7 +1005,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "-"
+     "slide_type": "fragment"
     }
    },
    "outputs": [
@@ -1049,7 +1061,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "-"
+     "slide_type": "subslide"
     }
    },
    "outputs": [
@@ -1070,14 +1082,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "## Indexing and Array Memory Management"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Numpy arrays support two different way of storing data into memory, namely\n",
     "\n",
@@ -1093,7 +1113,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Let's an example"
    ]
@@ -1102,7 +1126,10 @@
    "cell_type": "code",
    "execution_count": 17,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -1115,7 +1142,10 @@
    "cell_type": "code",
    "execution_count": 18,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -1125,7 +1155,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* **Note**: no changes in meaning for indexing operations"
    ]
@@ -1134,7 +1168,10 @@
    "cell_type": "code",
    "execution_count": 19,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1156,7 +1193,10 @@
    "cell_type": "code",
    "execution_count": 20,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1178,7 +1218,10 @@
    "cell_type": "code",
    "execution_count": 21,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -1200,7 +1243,10 @@
    "cell_type": "code",
    "execution_count": 22,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1220,7 +1266,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "<img src=\"images/storage_index.png\" />"
    ]
@@ -1251,7 +1301,7 @@
    "cell_type": "markdown",
    "metadata": {
     "slideshow": {
-     "slide_type": "-"
+     "slide_type": "fragment"
     }
    },
    "source": [
@@ -1323,7 +1373,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
    "source": [
     "With the `np.diag` function we can also extract the diagonal and subdiagonals of an array:"
    ]
@@ -1391,7 +1445,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
    "source": [
     "The `np.take` function is similar to fancy indexing described above:"
    ]
@@ -1522,7 +1580,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
    "source": [
     "Constructs and array by picking elements form several arrays:"
    ]
@@ -1559,7 +1621,7 @@
    "cell_type": "markdown",
    "metadata": {
     "slideshow": {
-     "slide_type": "subslide"
+     "slide_type": "slide"
     }
    },
    "source": [
@@ -1568,7 +1630,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "We can compute with subsets of the data in an array using indexing, fancy indexing, and the other methods of extracting data from an array (described above)."
    ]
@@ -1577,7 +1643,10 @@
    "cell_type": "code",
    "execution_count": 79,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -1592,7 +1661,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "fragment"
+     "slide_type": "subslide"
     }
    },
    "outputs": [
@@ -1628,7 +1697,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### Brief Preview (of some of the things presented in next notebooks)"
    ]
@@ -1674,7 +1747,10 @@
    "cell_type": "code",
    "execution_count": 83,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -1687,7 +1763,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "fragment"
+     "slide_type": "subslide"
     }
    },
    "outputs": [
@@ -1884,7 +1960,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "As mentioned several times by now, to get good performance we should try to avoid looping over elements in our vectors and matrices, and instead use vectorized algorithms. The first step in converting a scalar algorithm to a vectorized algorithm is to make sure that the functions we write work with vector inputs."
    ]
@@ -1952,7 +2032,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### `np.vectorize`"
    ]
@@ -1998,14 +2082,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### `np.frompyfunc`"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "**Universal functions** (Ufuncs) work on arrays, element-by-element, or on scalars. \n",
     "\n",
@@ -2016,7 +2108,10 @@
    "cell_type": "code",
    "execution_count": 105,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -2034,7 +2129,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "## Excercise"
    ]
@@ -2057,7 +2156,10 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -2077,7 +2179,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "When using arrays in conditions in for example `if` statements and other boolean expressions, one need to use one of `any` or `all`, which requires that any or all elements in the array evalutes to `True`:"
    ]
@@ -2139,7 +2245,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "fragment"
+     "slide_type": "subslide"
     }
    },
    "outputs": [
@@ -2160,6 +2266,7 @@
   }
  ],
  "metadata": {
+  "celltoolbar": "Slideshow",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",

03_Numpy_Operations.ipynb

@@ -13,7 +13,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "**Vectorizing** code is the key to writing efficient numerical calculation with Python/Numpy. \n",
     "\n",
@@ -26,7 +30,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "fragment"
+     "slide_type": "subslide"
     }
    },
    "outputs": [],
@@ -47,7 +51,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "We can use the usual arithmetic operators to multiply, add, subtract, and divide arrays with scalar numbers."
    ]
@@ -120,7 +128,10 @@
    "cell_type": "code",
    "execution_count": 28,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -133,7 +144,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "subslide"
+     "slide_type": "fragment"
     }
    },
    "outputs": [
@@ -174,7 +185,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "When we add, subtract, multiply and divide arrays with each other, the default behaviour is **element-wise** operations:"
    ]
@@ -311,7 +326,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "What about **matrix mutiplication**? \n",
     "\n",
@@ -401,7 +420,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "## A *new* dedicated Infix operator for Matrix Multiplication\n",
     "\n",
@@ -416,7 +439,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "### The `Matrix` Array Type"
    ]
@@ -438,7 +465,10 @@
    "cell_type": "code",
    "execution_count": 37,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -524,7 +554,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "fragment"
+     "slide_type": "subslide"
     }
    },
    "outputs": [
@@ -707,7 +737,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Above we have used the `.T` to transpose the matrix object `v`. We could also have used the `transpose` function to accomplish the same thing. \n",
     "\n",
@@ -908,7 +942,10 @@
    "cell_type": "code",
    "execution_count": 56,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -1006,7 +1043,10 @@
    "cell_type": "code",
    "execution_count": 58,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1029,7 +1069,10 @@
    "cell_type": "code",
    "execution_count": 59,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1063,7 +1106,10 @@
    "cell_type": "code",
    "execution_count": 60,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1085,7 +1131,10 @@
    "cell_type": "code",
    "execution_count": 61,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1116,7 +1165,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "The shape of an Numpy array can be modified without copying the underlaying data, which makes it a fast operation even for large arrays."
    ]
@@ -1125,7 +1178,10 @@
    "cell_type": "code",
    "execution_count": 65,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1247,7 +1303,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "### Flattening"
    ]
@@ -1260,12 +1320,12 @@
     }
    },
    "source": [
-    "We can also use the function `flatten` to make a higher-dimensional array into a vector. But this function create a copy of the data."
+    "### `np.ravel`"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 98,
    "metadata": {
     "collapsed": false,
     "slideshow": {
@@ -1276,24 +1336,22 @@
     {
      "data": {
       "text/plain": [
-       "array([ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
-       "       32, 33, 34, 40, 41, 42, 43, 44])"
+       "array([1, 2, 3, 4, 5, 6])"
       ]
      },
-     "execution_count": 70,
+     "execution_count": 98,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "B = A.flatten()\n",
-    "\n",
-    "B"
+    "a = np.array([[1, 2, 3], [4, 5, 6]])\n",
+    "a.ravel()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 99,
    "metadata": {
     "collapsed": false,
     "slideshow": {
@@ -1304,124 +1362,139 @@
     {
      "data": {
       "text/plain": [
-       "array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
-       "       32, 33, 34, 40, 41, 42, 43, 44])"
+       "array([[1, 4],\n",
+       "       [2, 5],\n",
+       "       [3, 6]])"
       ]
      },
-     "execution_count": 71,
+     "execution_count": 99,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "B[0:5] = 10\n",
-    "\n",
-    "B"
+    "a.T"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": 100,
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "fragment"
+     "slide_type": "subslide"
     }
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[ 5,  5,  5,  5,  5],\n",
-       "       [10, 11, 12, 13, 14],\n",
-       "       [20, 21, 22, 23, 24],\n",
-       "       [30, 31, 32, 33, 34],\n",
-       "       [40, 41, 42, 43, 44]])"
+       "array([1, 4, 2, 5, 3, 6])"
       ]
      },
-     "execution_count": 72,
+     "execution_count": 100,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "A # now A has not changed, because B's data is a copy of A's, not refering to the same data"
+    "a.T.ravel()"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
-    "### `np.ravel`"
+    "We can also use the function `flatten` to make a higher-dimensional array into a vector. But this function create a copy of the data."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 98,
+   "execution_count": 70,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([1, 2, 3, 4, 5, 6])"
+       "array([ 5,  5,  5,  5,  5, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
+       "       32, 33, 34, 40, 41, 42, 43, 44])"
       ]
      },
-     "execution_count": 98,
+     "execution_count": 70,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "a = np.array([[1, 2, 3], [4, 5, 6]])\n",
-    "a.ravel()"
+    "B = A.flatten()\n",
+    "\n",
+    "B"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 99,
+   "execution_count": 71,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[1, 4],\n",
-       "       [2, 5],\n",
-       "       [3, 6]])"
+       "array([10, 10, 10, 10, 10, 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31,\n",
+       "       32, 33, 34, 40, 41, 42, 43, 44])"
       ]
      },
-     "execution_count": 99,
+     "execution_count": 71,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "a.T"
+    "B[0:5] = 10\n",
+    "\n",
+    "B"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 100,
+   "execution_count": 72,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([1, 4, 2, 5, 3, 6])"
+       "array([[ 5,  5,  5,  5,  5],\n",
+       "       [10, 11, 12, 13, 14],\n",
+       "       [20, 21, 22, 23, 24],\n",
+       "       [30, 31, 32, 33, 34],\n",
+       "       [40, 41, 42, 43, 44]])"
       ]
      },
-     "execution_count": 100,
+     "execution_count": 72,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "a.T.ravel()"
+    "A # now A has not changed, because B's data is a copy of A's, not refering to the same data"
    ]
   },
   {
@@ -1437,7 +1510,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "With `newaxis`, we can insert new dimensions in an array, for example converting a vector to a column or row matrix:"
    ]
@@ -1574,7 +1651,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Using function `repeat`, `tile`, `vstack`, `hstack`, and `concatenate` we can create larger vectors and matrices from smaller ones:"
    ]
@@ -1594,7 +1675,10 @@
    "cell_type": "code",
    "execution_count": 82,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -1671,7 +1755,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "-"
+     "slide_type": "fragment"
     }
    },
    "outputs": [],
@@ -1747,7 +1831,10 @@
    "cell_type": "code",
    "execution_count": 88,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1771,7 +1858,10 @@
    "cell_type": "code",
    "execution_count": 89,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -1803,7 +1893,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "To achieve high performance, assignments in Python usually do not copy the underlaying objects. \n",
     "\n",
@@ -1816,7 +1910,10 @@
    "cell_type": "code",
    "execution_count": 90,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -1843,7 +1940,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "subslide"
+     "slide_type": "fragment"
     }
    },
    "outputs": [],
@@ -1989,14 +2086,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "# Exercise: Shape manipulations"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* Look at the docstring for `reshape`, especially the notes section which\n",
     "has some more information about copies and views.\n",
@@ -2009,6 +2114,7 @@
   }
  ],
  "metadata": {
+  "celltoolbar": "Slideshow",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",

04_Data_Processing.ipynb

@@ -40,7 +40,7 @@
    "cell_type": "markdown",
    "metadata": {
     "slideshow": {
-     "slide_type": "-"
+     "slide_type": "subslide"
     }
    },
    "source": [
@@ -121,7 +121,10 @@
    "cell_type": "code",
    "execution_count": 9,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -134,7 +137,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "fragment"
+     "slide_type": "subslide"
     }
    },
    "outputs": [
@@ -277,7 +280,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* Useful when storing and reading back numpy array data. \n",
     "\n",
@@ -286,7 +293,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### `np.save`"
    ]
@@ -317,7 +328,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### `np.load`"
    ]
@@ -349,7 +364,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "## Matlab Users\n",
     "\n",
@@ -360,7 +379,10 @@
    "cell_type": "code",
    "execution_count": 42,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -371,7 +393,10 @@
    "cell_type": "code",
    "execution_count": 43,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -398,7 +423,10 @@
    "cell_type": "code",
    "execution_count": 45,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -437,7 +465,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Often it is useful to store datasets in Numpy arrays. Numpy provides a number of functions to calculate statistics of datasets in arrays. \n",
     "\n",
@@ -485,7 +517,10 @@
    "cell_type": "code",
    "execution_count": 25,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -506,7 +541,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
    "source": [
     "The daily mean temperature in Stockholm over the last 200 year so has been about 6.2 C."
    ]
@@ -526,7 +565,10 @@
    "cell_type": "code",
    "execution_count": 26,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -559,7 +601,10 @@
    "cell_type": "code",
    "execution_count": 27,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -582,7 +627,10 @@
    "cell_type": "code",
    "execution_count": 28,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -616,7 +664,10 @@
    "cell_type": "code",
    "execution_count": 29,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -641,7 +692,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "-"
+     "slide_type": "fragment"
     }
    },
    "outputs": [
@@ -780,7 +831,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "When functions such as `min`, `max`, etc., is applied to a multidimensional arrays, it is sometimes useful to apply the calculation to the entire array, and sometimes only on a row or column basis. Using the `axis` argument we can specify how these functions should behave: "
    ]
@@ -791,7 +846,7 @@
    "metadata": {
     "collapsed": false,
     "slideshow": {
-     "slide_type": "fragment"
+     "slide_type": "subslide"
     }
    },
    "outputs": [
@@ -869,7 +924,10 @@
    "cell_type": "code",
    "execution_count": 41,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -890,13 +948,18 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Many other functions and methods in the `array` and `matrix` classes accept the same (optional) `axis` keyword argument."
    ]
   }
  ],
  "metadata": {
+  "celltoolbar": "Slideshow",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",

05_Memmapping.ipynb

@@ -2,14 +2,22 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "# Memmapping"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "The numpy package makes it possible to memory map large contiguous chunks of binary files as shared memory for all the Python processes running on a given host:"
    ]
@@ -18,7 +26,10 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -27,7 +38,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* Creating a `numpy.memmap` instance with the `w+` mode creates a file on the filesystem and zeros its content. "
    ]
@@ -36,7 +51,10 @@
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -62,7 +80,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* This binary file can then be mapped as a new numpy array by all the engines having access to the same filesystem. \n",
     "* The `mode='r+'` opens this shared memory area in read write mode:"
@@ -72,7 +94,10 @@
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -92,7 +117,10 @@
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -112,7 +140,10 @@
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -129,7 +160,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* Memory mapped arrays created with `mode='r+'` can be modified and the modifications are shared \n",
     "    - in case of multiple process"
@@ -139,7 +174,10 @@
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -150,7 +188,10 @@
    "cell_type": "code",
    "execution_count": 13,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -167,14 +208,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "### Memmap Operations"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Memmap arrays generally behave very much like regular in-memory numpy arrays:"
    ]
@@ -183,7 +232,10 @@
    "cell_type": "code",
    "execution_count": 14,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -203,14 +255,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Before allocating more data let us define a couple of utility functions from the previous exercise (and more) to monitor what is used by which engine and what is still free on the cluster as a whole:"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* Let's allocate a 80MB memmap array:"
    ]
@@ -219,7 +279,10 @@
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -244,7 +307,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "No significant memory was used in this operation as we just asked the OS to allocate the buffer on the hard drive and just maitain a virtual memory area as a cheap reference to this buffer.\n",
     "\n",
@@ -255,7 +322,10 @@
    "cell_type": "code",
    "execution_count": 17,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -275,7 +345,10 @@
    "cell_type": "code",
    "execution_count": 18,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -295,7 +368,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* Let's trigger an actual load of the data from the drive into the in-memory disk cache of the OS, this can take some time depending on the speed of the hard drive (on the order of 100MB/s to 300MB/s hence 3s to 8s for this dataset):"
    ]
@@ -304,7 +381,10 @@
    "cell_type": "code",
    "execution_count": 19,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -332,7 +412,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "* Now back into memory"
    ]
@@ -341,7 +425,10 @@
    "cell_type": "code",
    "execution_count": 20,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -369,7 +456,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "### Example of practical use of this approach"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "This strategy makes it very interesting to load the readonly datasets of machine learning problems, especially when the same data is reused over and over by concurrent processes as can be the case when doing learning curves analysis or grid search (**Hyperparameter Optimisation** & **Model Selection**).\n",
     "\n",
@@ -378,14 +480,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "## Memmaping Nested Numpy-based Data Structures with Joblib"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "**joblib** is a utility library included in the **sklearn** package. Among other things it provides tools to serialize objects that comprise large numpy arrays and reload them as memmap backed datastructures.\n",
     "\n",
@@ -396,7 +506,10 @@
    "cell_type": "code",
    "execution_count": 21,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -429,7 +542,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "We can now persist this datastructure to disk:"
    ]
@@ -438,7 +555,10 @@
    "cell_type": "code",
    "execution_count": 22,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -463,7 +583,10 @@
    "cell_type": "code",
    "execution_count": 23,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -482,7 +605,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "A memmapped copy of this datastructure can then be loaded:"
    ]
@@ -491,7 +618,10 @@
    "cell_type": "code",
    "execution_count": 24,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -517,6 +647,7 @@
   }
  ],
  "metadata": {
+  "celltoolbar": "Slideshow",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",

06_Numexpr.ipynb

@@ -2,10 +2,23 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "# Numexpr"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
-    "# Numexpr\n",
-    "\n",
     "**Numexpr** is a fast numerical expression evaluator for NumPy. \n",
     "\n",
     "With it, expressions that operate on arrays (like `3*a+4*b`) are accelerated and use less memory than doing the same calculation in Python.\n",
@@ -19,7 +32,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "## Some Examples \n",
     "\n",
@@ -30,7 +47,10 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -42,7 +62,10 @@
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -54,7 +77,10 @@
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -77,7 +103,10 @@
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -99,7 +128,10 @@
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -120,7 +152,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "## Time Comparison with Numpy"
    ]
@@ -129,7 +165,10 @@
    "cell_type": "code",
    "execution_count": 8,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -148,7 +187,10 @@
    "cell_type": "code",
    "execution_count": 9,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -167,7 +209,10 @@
    "cell_type": "code",
    "execution_count": 10,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -186,7 +231,10 @@
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -203,7 +251,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### (some) preliminary conclusions\n",
     "\n",
@@ -214,7 +266,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "# NumExpr supported Datatypes\n",
     "\n",
@@ -229,6 +285,7 @@
   }
  ],
  "metadata": {
+  "celltoolbar": "Slideshow",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",

07_0_MachineLearning_Data.ipynb

@@ -2,14 +2,22 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "# Machine Learning (and Numpy Arrays)"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Machine Learning is about building programs with **tunable parameters** (typically an\n",
     "array of floating point values) that are adjusted automatically so as to improve\n",
@@ -25,14 +33,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "## *Data* for Machine Learning Algorithms"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Data in machine learning algorithms, with very few exceptions, is assumed to be stored as a\n",
     "**two-dimensional array**, of size `[n_samples, n_features]`.\n",
@@ -58,7 +74,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### Addendum\n",
     "\n",
@@ -67,7 +87,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "## A Simple Example: the Iris Dataset"
    ]
@@ -76,7 +100,10 @@
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -147,7 +174,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "- Features in the Iris dataset:\n",
     "\n",
@@ -167,7 +198,10 @@
    "cell_type": "code",
    "execution_count": 47,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -177,7 +211,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Try by yourself one of the following commands where *'d'* is the variable containing the dataset:\n",
     "\n",
@@ -193,7 +231,10 @@
    "cell_type": "code",
    "execution_count": 48,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -212,7 +253,10 @@
    "cell_type": "code",
    "execution_count": 49,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "skip"
+    }
    },
    "outputs": [
     {
@@ -290,7 +334,10 @@
    "cell_type": "code",
    "execution_count": 50,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -309,7 +356,10 @@
    "cell_type": "code",
    "execution_count": 51,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -327,7 +377,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "## Spatial and Clustering Analysis\n",
     "\n",
@@ -337,35 +391,55 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "<img src=\"images/cluster_0.png\">"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "<img src=\"images/cluster_1.png\">"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "<img src=\"images/modeling_data_flow.png\">"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "## Machine Learning with SciPy"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "**SciPy** provides a spatial analysis class (`scipy.spatial`) and a cluster analysis class (`scipy.cluster`). \n",
     "\n",
@@ -385,7 +459,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### Simple Example"
    ]
@@ -394,7 +472,10 @@
    "cell_type": "code",
    "execution_count": 11,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -406,7 +487,10 @@
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -420,7 +504,10 @@
    "cell_type": "code",
    "execution_count": 13,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -432,7 +519,10 @@
    "cell_type": "code",
    "execution_count": 14,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -444,7 +534,10 @@
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -458,7 +551,10 @@
    "cell_type": "code",
    "execution_count": 16,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -472,7 +568,10 @@
    "cell_type": "code",
    "execution_count": 100,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "skip"
+    }
    },
    "outputs": [],
    "source": [
@@ -483,7 +582,10 @@
    "cell_type": "code",
    "execution_count": 102,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -494,7 +596,10 @@
    "cell_type": "code",
    "execution_count": 105,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -515,7 +620,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### Iris Example"
    ]
@@ -524,7 +633,10 @@
    "cell_type": "code",
    "execution_count": 52,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -549,7 +661,10 @@
    "cell_type": "code",
    "execution_count": 53,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -577,7 +692,10 @@
    "cell_type": "code",
    "execution_count": 91,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -597,7 +715,10 @@
    "cell_type": "code",
    "execution_count": 92,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -609,7 +730,10 @@
    "cell_type": "code",
    "execution_count": 93,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -623,7 +747,10 @@
    "cell_type": "code",
    "execution_count": 94,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -642,7 +769,10 @@
    "cell_type": "code",
    "execution_count": 95,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -653,7 +783,10 @@
    "cell_type": "code",
    "execution_count": 96,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -665,7 +798,10 @@
    "cell_type": "code",
    "execution_count": 97,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [],
    "source": [
@@ -676,7 +812,10 @@
    "cell_type": "code",
    "execution_count": 98,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -689,7 +828,10 @@
    "cell_type": "code",
    "execution_count": 106,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -710,14 +852,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "## Note about `kmeans` in `scipy.cluster`"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "In `scipy.cluster` we have **two** routines to divide data into clusters using the **k-means technique**:\n",
     "\n",
@@ -755,14 +905,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "## Machine Learning with scikit-learn"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### What is scikit-learn?\n",
     "\n",
@@ -773,7 +931,10 @@
    "cell_type": "code",
    "execution_count": 107,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [],
    "source": [
@@ -783,7 +944,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### Plotting the (randomly generated) data\n",
     "\n",
@@ -794,7 +959,10 @@
    "cell_type": "code",
    "execution_count": 110,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -830,7 +998,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Now we can use **KMeans** to find the centers of these clusters.\n",
     "\n",
@@ -841,7 +1013,10 @@
    "cell_type": "code",
    "execution_count": 111,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -869,7 +1044,10 @@
    "cell_type": "code",
    "execution_count": 113,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -899,7 +1077,10 @@
    "cell_type": "code",
    "execution_count": 114,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -922,7 +1103,10 @@
    "cell_type": "code",
    "execution_count": 116,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -946,7 +1130,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "The `transform` function is quite useful in the sense that it will output the distance between\n",
     "each point and centroid:"
@@ -956,7 +1144,10 @@
    "cell_type": "code",
    "execution_count": 118,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "fragment"
+    }
    },
    "outputs": [
     {
@@ -980,6 +1171,7 @@
   }
  ],
  "metadata": {
+  "celltoolbar": "Slideshow",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",

07_1_Sparse_Matrices.ipynb

@@ -24,7 +24,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "**Sparse Matrices** are very nice in some situations.  \n",
     "\n",
@@ -40,7 +44,10 @@
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {
-    "collapsed": true
+    "collapsed": true,
+    "slideshow": {
+     "slide_type": "skip"
+    }
    },
    "outputs": [],
    "source": [
@@ -336,7 +343,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "## CSC - Compressed Sparse Column\n",
     "\n",
@@ -354,7 +365,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "### BSR - Block Sparse Row\n",
     "\n",
@@ -371,7 +386,10 @@
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -401,7 +419,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "## COO - Coordinate Sparse Matrix\n",
     "\n",
@@ -426,7 +448,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "## DOK - Dictionary of Keys\n",
     "\n",
@@ -439,7 +465,10 @@
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "slideshow": {
+     "slide_type": "subslide"
+    }
    },
    "outputs": [
     {
@@ -469,7 +498,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "The ``scipy.sparse`` submodule also has a lot of functions for sparse matrices\n",
     "including linear algebra, sparse solvers, graph algorithms, and much more."
@@ -477,6 +510,7 @@
   }
  ],
  "metadata": {
+  "celltoolbar": "Slideshow",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",

08_A_look_at_the_future.ipynb

@@ -2,14 +2,22 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
    "source": [
     "# The future of Numpy"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "The future of NumPy is **Blaze**, a new open source Python numerical library. \n",
     "\n",
@@ -26,14 +34,22 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "**Blaze Project**: [http://blaze.pydata.org/]()"
    ]
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "fragment"
+    }
+   },
    "source": [
     "Blaze is centered around **general multidimensional array** and **table abstractions**. \n",
     "\n",
@@ -44,7 +60,11 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {},
+   "metadata": {
+    "slideshow": {
+     "slide_type": "subslide"
+    }
+   },
    "source": [
     "Blaze extends NumPy to provide custom-defined data types and heterogeneous shapes. \n",
     "\n",
@@ -60,6 +80,7 @@
   }
  ],
  "metadata": {
+  "celltoolbar": "Slideshow",
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",