diff options
Diffstat (limited to 'ML/01_intro/tools_numpy.ipynb')
| -rw-r--r-- | ML/01_intro/tools_numpy.ipynb | 5073 |
1 files changed, 5073 insertions, 0 deletions
diff --git a/ML/01_intro/tools_numpy.ipynb b/ML/01_intro/tools_numpy.ipynb new file mode 100644 index 0000000..4beaa3d --- /dev/null +++ b/ML/01_intro/tools_numpy.ipynb @@ -0,0 +1,5073 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Tools - NumPy**\n", + "\n", + "*NumPy is the fundamental library for scientific computing with Python. NumPy is centered around a powerful N-dimensional array object, and it also contains useful linear algebra, Fourier transform, and random number functions.*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "<table align=\"left\">\n", + " <td>\n", + " <a href=\"https://colab.research.google.com/github/ageron/handson-ml3/blob/main/tools_numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n", + " </td>\n", + " <td>\n", + " <a target=\"_blank\" href=\"https://kaggle.com/kernels/welcome?src=https://github.com/ageron/handson-ml3/blob/main/tools_numpy.ipynb\"><img src=\"https://kaggle.com/static/images/open-in-kaggle.svg\" /></a>\n", + " </td>\n", + "</table>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Creating Arrays" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's import `numpy`. Most people import it as `np`:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `np.zeros`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `zeros` function creates an array containing any number of zeros:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's just as easy to create a 2D array (i.e. a matrix) by providing a tuple with the desired number of rows and columns. For example, here's a 3x4 matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros((3,4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Some vocabulary\n", + "\n", + "* In NumPy, each dimension is called an **axis**.\n", + "* The number of axes is called the **rank**.\n", + " * For example, the above 3x4 matrix is an array of rank 2 (it is 2-dimensional).\n", + " * The first axis has length 3, the second has length 4.\n", + "* An array's list of axis lengths is called the **shape** of the array.\n", + " * For example, the above matrix's shape is `(3, 4)`.\n", + " * The rank is equal to the shape's length.\n", + "* The **size** of an array is the total number of elements, which is the product of all axis lengths (e.g. 3*4=12)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.zeros((3,4))\n", + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 4)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.ndim # equal to len(a.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a.size" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## N-dimensional arrays\n", + "You can also create an N-dimensional array of arbitrary rank. For example, here's a 3D array (rank=3), with shape `(2,3,4)`:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros((2,3,4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Array type\n", + "NumPy arrays have the type `ndarray`s:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "numpy.ndarray" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(np.zeros((3,4)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `np.ones`\n", + "Many other NumPy functions create `ndarray`s.\n", + "\n", + "Here's a 3x4 matrix full of ones:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., 1.],\n", + " [1., 1., 1., 1.],\n", + " [1., 1., 1., 1.]])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.ones((3,4))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `np.full`\n", + "Creates an array of the given shape initialized with the given value. Here's a 3x4 matrix full of `π`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[3.14159265, 3.14159265, 3.14159265, 3.14159265],\n", + " [3.14159265, 3.14159265, 3.14159265, 3.14159265],\n", + " [3.14159265, 3.14159265, 3.14159265, 3.14159265]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.full((3,4), np.pi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `np.empty`\n", + "An uninitialized 2x3 array (its content is not predictable, as it is whatever is in memory at that point):" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.00e+000, 3.06e-322, 0.00e+000],\n", + " [0.00e+000, 0.00e+000, 0.00e+000]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.empty((2,3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## np.array\n", + "Of course, you can initialize an `ndarray` using a regular python array. Just call the `array` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, 2, 3, 4],\n", + " [10, 20, 30, 40]])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([[1,2,3,4], [10, 20, 30, 40]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `np.arange`\n", + "You can create an `ndarray` using NumPy's `arange` function, which is similar to python's built-in `range` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 2, 3, 4])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(1, 5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It also works with floats:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1., 2., 3., 4.])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(1.0, 5.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Of course, you can provide a step parameter:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.arange(1, 5, 0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, when dealing with floats, the exact number of elements in the array is not always predictable. For example, consider this:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 0.33333333 0.66666667 1. 1.33333333 1.66666667]\n", + "[0. 0.33333333 0.66666667 1. 1.33333333 1.66666667]\n", + "[0. 0.33333333 0.66666667 1. 1.33333334]\n" + ] + } + ], + "source": [ + "print(np.arange(0, 5/3, 1/3)) # depending on floating point errors, the max value is 4/3 or 5/3.\n", + "print(np.arange(0, 5/3, 0.333333333))\n", + "print(np.arange(0, 5/3, 0.333333334))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `np.linspace`\n", + "For this reason, it is generally preferable to use the `linspace` function instead of `arange` when working with floats. The `linspace` function returns an array containing a specific number of points evenly distributed between two values (note that the maximum value is *included*, contrary to `arange`):" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 0.33333333 0.66666667 1. 1.33333333 1.66666667]\n" + ] + } + ], + "source": [ + "print(np.linspace(0, 5/3, 6))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `np.rand` and `np.randn`\n", + "A number of functions are available in NumPy's `random` module to create `ndarray`s initialized with random values.\n", + "For example, here is a 3x4 matrix initialized with random floats between 0 and 1 (uniform distribution):" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.47698476, 0.39453995, 0.09641682, 0.67521148],\n", + " [0.41412975, 0.44694094, 0.62320442, 0.90437753],\n", + " [0.31266721, 0.50163731, 0.96093721, 0.38303191]])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.rand(3,4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's a 3x4 matrix containing random floats sampled from a univariate [normal distribution](https://en.wikipedia.org/wiki/Normal_distribution) (Gaussian distribution) of mean 0 and variance 1:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.18260514e-01, 1.09540729e-01, 7.98591536e-04,\n", + " 8.32733930e-01],\n", + " [ 5.89942056e-01, 1.06164114e+00, 9.26427739e-01,\n", + " 3.50822290e-02],\n", + " [-1.18654745e+00, 3.13723026e-01, -2.01279322e-01,\n", + " -6.71803289e-01]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.randn(3,4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To give you a feel of what these distributions look like, let's use matplotlib (see the [matplotlib tutorial](tools_matplotlib.ipynb) for more details):" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(np.random.rand(100000), density=True, bins=100, histtype=\"step\", color=\"blue\", label=\"rand\")\n", + "plt.hist(np.random.randn(100000), density=True, bins=100, histtype=\"step\", color=\"red\", label=\"randn\")\n", + "plt.axis([-2.5, 2.5, 0, 1.1])\n", + "plt.legend(loc = \"upper left\")\n", + "plt.title(\"Random distributions\")\n", + "plt.xlabel(\"Value\")\n", + "plt.ylabel(\"Density\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## np.fromfunction\n", + "You can also initialize an `ndarray` using a function:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.],\n", + " [ 10., 11., 12., 13., 14., 15., 16., 17., 18., 19.]],\n", + "\n", + " [[100., 101., 102., 103., 104., 105., 106., 107., 108., 109.],\n", + " [110., 111., 112., 113., 114., 115., 116., 117., 118., 119.]],\n", + "\n", + " [[200., 201., 202., 203., 204., 205., 206., 207., 208., 209.],\n", + " [210., 211., 212., 213., 214., 215., 216., 217., 218., 219.]]])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def my_function(z, y, x):\n", + " return x + 10 * y + 100 * z\n", + "\n", + "np.fromfunction(my_function, (3, 2, 10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NumPy first creates three `ndarray`s (one per dimension), each of shape `(3, 2, 10)`. Each array has values equal to the coordinate along a specific axis. For example, all elements in the `z` array are equal to their z-coordinate:\n", + "\n", + " [[[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n", + " \n", + " [[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n", + " [ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]\n", + " \n", + " [[ 2. 2. 2. 2. 2. 2. 2. 2. 2. 2.]\n", + " [ 2. 2. 2. 2. 2. 2. 2. 2. 2. 2.]]]\n", + "\n", + "So the terms `x`, `y` and `z` in the expression `x + 10 * y + 100 * z` above are in fact `ndarray`s (we will discuss arithmetic operations on arrays below). The point is that the function `my_function` is only called *once*, instead of once per element. This makes initialization very efficient." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Array data\n", + "## `dtype`\n", + "NumPy's `ndarray`s are also efficient in part because all their elements must have the same type (usually numbers).\n", + "You can check what the data type is by looking at the `dtype` attribute:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "int64 [1 2 3 4]\n" + ] + } + ], + "source": [ + "c = np.arange(1, 5)\n", + "print(c.dtype, c)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "float64 [1. 2. 3. 4.]\n" + ] + } + ], + "source": [ + "c = np.arange(1.0, 5.0)\n", + "print(c.dtype, c)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instead of letting NumPy guess what data type to use, you can set it explicitly when creating an array by setting the `dtype` parameter:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "complex64 [1.+0.j 2.+0.j 3.+0.j 4.+0.j]\n" + ] + } + ], + "source": [ + "d = np.arange(1, 5, dtype=np.complex64)\n", + "print(d.dtype, d)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Available data types include signed `int8`, `int16`, `int32`, `int64`, unsigned `uint8`|`16`|`32`|`64`, `float16`|`32`|`64` and `complex64`|`128`. Check out the documentation for the [basic types](https://numpy.org/doc/stable/user/basics.types.html) and [sized aliases](https://numpy.org/doc/stable/reference/arrays.scalars.html#sized-aliases) for the full list.\n", + "\n", + "## `itemsize`\n", + "The `itemsize` attribute returns the size (in bytes) of each item:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "e = np.arange(1, 5, dtype=np.complex64)\n", + "e.itemsize" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `data` buffer\n", + "An array's data is actually stored in memory as a flat (one dimensional) byte buffer. It is available *via* the `data` attribute (you will rarely need it, though)." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<memory at 0x127dc16c0>" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f = np.array([[1,2],[1000, 2000]], dtype=np.int32)\n", + "f.data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In python 2, `f.data` is a buffer. In python 3, it is a memoryview." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "b'\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\xe8\\x03\\x00\\x00\\xd0\\x07\\x00\\x00'" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "if hasattr(f.data, \"tobytes\"):\n", + " data_bytes = f.data.tobytes() # python 3\n", + "else:\n", + " data_bytes = memoryview(f.data).tobytes() # python 2\n", + "\n", + "data_bytes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Several `ndarray`s can share the same data buffer, meaning that modifying one will also modify the others. We will see an example in a minute." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Reshaping an array\n", + "## In place\n", + "Changing the shape of an `ndarray` is as simple as setting its `shape` attribute. However, the array's size must remain the same." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]\n", + "Rank: 1\n" + ] + } + ], + "source": [ + "g = np.arange(24)\n", + "print(g)\n", + "print(\"Rank:\", g.ndim)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0 1 2 3]\n", + " [ 4 5 6 7]\n", + " [ 8 9 10 11]\n", + " [12 13 14 15]\n", + " [16 17 18 19]\n", + " [20 21 22 23]]\n", + "Rank: 2\n" + ] + } + ], + "source": [ + "g.shape = (6, 4)\n", + "print(g)\n", + "print(\"Rank:\", g.ndim)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[[ 0 1 2 3]\n", + " [ 4 5 6 7]\n", + " [ 8 9 10 11]]\n", + "\n", + " [[12 13 14 15]\n", + " [16 17 18 19]\n", + " [20 21 22 23]]]\n", + "Rank: 3\n" + ] + } + ], + "source": [ + "g.shape = (2, 3, 4)\n", + "print(g)\n", + "print(\"Rank:\", g.ndim)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `reshape`\n", + "The `reshape` function returns a new `ndarray` object pointing at the *same* data. This means that modifying one array will also modify the other." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0 1 2 3 4 5]\n", + " [ 6 7 8 9 10 11]\n", + " [12 13 14 15 16 17]\n", + " [18 19 20 21 22 23]]\n", + "Rank: 2\n" + ] + } + ], + "source": [ + "g2 = g.reshape(4,6)\n", + "print(g2)\n", + "print(\"Rank:\", g2.ndim)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set item at row 1, col 2 to 999 (more about indexing below)." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4, 5],\n", + " [ 6, 7, 999, 9, 10, 11],\n", + " [ 12, 13, 14, 15, 16, 17],\n", + " [ 18, 19, 20, 21, 22, 23]])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g2[1, 2] = 999\n", + "g2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The corresponding element in `g` has been modified." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7],\n", + " [999, 9, 10, 11]],\n", + "\n", + " [[ 12, 13, 14, 15],\n", + " [ 16, 17, 18, 19],\n", + " [ 20, 21, 22, 23]]])" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `ravel`\n", + "Finally, the `ravel` function returns a new one-dimensional `ndarray` that also points to the same data:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 999, 9, 10, 11, 12,\n", + " 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.ravel()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Arithmetic operations\n", + "All the usual arithmetic operators (`+`, `-`, `*`, `/`, `//`, `**`, etc.) can be used with `ndarray`s. They apply *elementwise*:" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a + b = [19 27 35 43]\n", + "a - b = [ 9 19 29 39]\n", + "a * b = [70 92 96 82]\n", + "a / b = [ 2.8 5.75 10.66666667 20.5 ]\n", + "a // b = [ 2 5 10 20]\n", + "a % b = [4 3 2 1]\n", + "a ** b = [537824 279841 32768 1681]\n" + ] + } + ], + "source": [ + "a = np.array([14, 23, 32, 41])\n", + "b = np.array([5, 4, 3, 2])\n", + "print(\"a + b =\", a + b)\n", + "print(\"a - b =\", a - b)\n", + "print(\"a * b =\", a * b)\n", + "print(\"a / b =\", a / b)\n", + "print(\"a // b =\", a // b)\n", + "print(\"a % b =\", a % b)\n", + "print(\"a ** b =\", a ** b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the multiplication is *not* a matrix multiplication. We will discuss matrix operations below.\n", + "\n", + "The arrays must have the same shape. If they do not, NumPy will apply the *broadcasting rules*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Broadcasting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In general, when NumPy expects arrays of the same shape but finds that this is not the case, it applies the so-called *broadcasting* rules:\n", + "\n", + "## First rule\n", + "*If the arrays do not have the same rank, then a 1 will be prepended to the smaller ranking arrays until their ranks match.*" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0, 1, 2, 3, 4]]])" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h = np.arange(5).reshape(1, 1, 5)\n", + "h" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's try to add a 1D array of shape `(5,)` to this 3D array of shape `(1,1,5)`. Applying the first rule of broadcasting!" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[10, 21, 32, 43, 54]]])" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h + [10, 20, 30, 40, 50] # same as: h + [[[10, 20, 30, 40, 50]]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Second rule\n", + "*Arrays with a 1 along a particular dimension act as if they had the size of the array with the largest shape along that dimension. The value of the array element is repeated along that dimension.*" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 1, 2],\n", + " [3, 4, 5]])" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k = np.arange(6).reshape(2, 3)\n", + "k" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try to add a 2D array of shape `(2,1)` to this 2D `ndarray` of shape `(2, 3)`. NumPy will apply the second rule of broadcasting:" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[100, 101, 102],\n", + " [203, 204, 205]])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k + [[100], [200]] # same as: k + [[100, 100, 100], [200, 200, 200]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Combining rules 1 & 2, we can do this:" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[100, 201, 302],\n", + " [103, 204, 305]])" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k + [100, 200, 300] # after rule 1: [[100, 200, 300]], and after rule 2: [[100, 200, 300], [100, 200, 300]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And also, very simply:" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1000, 1001, 1002],\n", + " [1003, 1004, 1005]])" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "k + 1000 # same as: k + [[1000, 1000, 1000], [1000, 1000, 1000]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Third rule\n", + "*After rules 1 & 2, the sizes of all arrays must match.*" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "operands could not be broadcast together with shapes (2,3) (2,) \n" + ] + } + ], + "source": [ + "try:\n", + " k + [33, 44]\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Broadcasting rules are used in many NumPy operations, not just arithmetic operations, as we will see below.\n", + "For more details about broadcasting, check out [the documentation](https://numpy.org/doc/stable/user/basics.broadcasting.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Upcasting\n", + "When trying to combine arrays with different `dtype`s, NumPy will *upcast* to a type capable of handling all possible values (regardless of what the *actual* values are)." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "uint8 [0 1 2 3 4]\n" + ] + } + ], + "source": [ + "k1 = np.arange(0, 5, dtype=np.uint8)\n", + "print(k1.dtype, k1)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "int16 [ 5 7 9 11 13]\n" + ] + } + ], + "source": [ + "k2 = k1 + np.array([5, 6, 7, 8, 9], dtype=np.int8)\n", + "print(k2.dtype, k2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that `int16` is required to represent all *possible* `int8` and `uint8` values (from -128 to 255), even though in this case a `uint8` would have sufficed." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "float64 [1.5 2.5 3.5 4.5 5.5]\n" + ] + } + ], + "source": [ + "k3 = k1 + 1.5\n", + "print(k3.dtype, k3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Conditional operators" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The conditional operators also apply elementwise:" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([False, True, True, False])" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m = np.array([20, -5, 30, 40])\n", + "m < [15, 16, 35, 36]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And using broadcasting:" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ True, True, False, False])" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m < 25 # equivalent to m < [25, 25, 25, 25]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is most useful in conjunction with boolean indexing (discussed below)." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([20, -5])" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m[m < 25]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mathematical and statistical functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Many mathematical and statistical functions are available for `ndarray`s.\n", + "\n", + "## `ndarray` methods\n", + "Some functions are simply `ndarray` methods, for example:" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-2.5 3.1 7. ]\n", + " [10. 11. 12. ]]\n", + "mean = 6.766666666666667\n" + ] + } + ], + "source": [ + "a = np.array([[-2.5, 3.1, 7], [10, 11, 12]])\n", + "print(a)\n", + "print(\"mean =\", a.mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that this computes the mean of all elements in the `ndarray`, regardless of its shape.\n", + "\n", + "Here are a few more useful `ndarray` methods:" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "min = -2.5\n", + "max = 12.0\n", + "sum = 40.6\n", + "prod = -71610.0\n", + "std = 5.084835843520964\n", + "var = 25.855555555555554\n" + ] + } + ], + "source": [ + "for func in (a.min, a.max, a.sum, a.prod, a.std, a.var):\n", + " print(func.__name__, \"=\", func())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These functions accept an optional argument `axis` which lets you ask for the operation to be performed on elements along the given axis. For example:" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7],\n", + " [ 8, 9, 10, 11]],\n", + "\n", + " [[12, 13, 14, 15],\n", + " [16, 17, 18, 19],\n", + " [20, 21, 22, 23]]])" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c=np.arange(24).reshape(2,3,4)\n", + "c" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[12, 14, 16, 18],\n", + " [20, 22, 24, 26],\n", + " [28, 30, 32, 34]])" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.sum(axis=0) # sum across matrices" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[12, 15, 18, 21],\n", + " [48, 51, 54, 57]])" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.sum(axis=1) # sum across rows" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also sum over multiple axes:" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 60, 92, 124])" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c.sum(axis=(0,2)) # sum across matrices and columns" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(60, 92, 124)" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "0+1+2+3 + 12+13+14+15, 4+5+6+7 + 16+17+18+19, 8+9+10+11 + 20+21+22+23" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Universal functions\n", + "NumPy also provides fast elementwise functions called *universal functions*, or **ufunc**. They are vectorized wrappers of simple functions. For example `square` returns a new `ndarray` which is a copy of the original `ndarray` except that each element is squared:" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 6.25, 9.61, 49. ],\n", + " [100. , 121. , 144. ]])" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([[-2.5, 3.1, 7], [10, 11, 12]])\n", + "np.square(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are a few more useful unary ufuncs:" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original ndarray\n", + "[[-2.5 3.1 7. ]\n", + " [10. 11. 12. ]]\n", + "\n", + " absolute\n", + "[[ 2.5 3.1 7. ]\n", + " [10. 11. 12. ]]\n", + "\n", + " sqrt\n", + "[[ nan 1.76068169 2.64575131]\n", + " [3.16227766 3.31662479 3.46410162]]\n", + "\n", + " exp\n", + "[[8.20849986e-02 2.21979513e+01 1.09663316e+03]\n", + " [2.20264658e+04 5.98741417e+04 1.62754791e+05]]\n", + "\n", + " log\n", + "[[ nan 1.13140211 1.94591015]\n", + " [2.30258509 2.39789527 2.48490665]]\n", + "\n", + " sign\n", + "[[-1. 1. 1.]\n", + " [ 1. 1. 1.]]\n", + "\n", + " ceil\n", + "[[-2. 4. 7.]\n", + " [10. 11. 12.]]\n", + "\n", + " modf\n", + "(array([[-0.5, 0.1, 0. ],\n", + " [ 0. , 0. , 0. ]]), array([[-2., 3., 7.],\n", + " [10., 11., 12.]]))\n", + "\n", + " isnan\n", + "[[False False False]\n", + " [False False False]]\n", + "\n", + " cos\n", + "[[-0.80114362 -0.99913515 0.75390225]\n", + " [-0.83907153 0.0044257 0.84385396]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/lf/d71zm48s6y7c391ynbnyp85w0000gp/T/ipykernel_81957/2634842825.py:5: RuntimeWarning: invalid value encountered in sqrt\n", + " print(func(a))\n", + "/var/folders/lf/d71zm48s6y7c391ynbnyp85w0000gp/T/ipykernel_81957/2634842825.py:5: RuntimeWarning: invalid value encountered in log\n", + " print(func(a))\n" + ] + } + ], + "source": [ + "print(\"Original ndarray\")\n", + "print(a)\n", + "for func in (np.abs, np.sqrt, np.exp, np.log, np.sign, np.ceil, np.modf, np.isnan, np.cos):\n", + " print(\"\\n\", func.__name__)\n", + " print(func(a))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The two warnings are due to the fact that `sqrt()` and `log()` are undefined for negative numbers, which is why there is a `np.nan` value in the first cell of the output of these two functions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Binary ufuncs\n", + "There are also many binary ufuncs, that apply elementwise on two `ndarray`s. Broadcasting rules are applied if the arrays do not have the same shape:" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 3, 6, 2, 11])" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([1, -2, 3, 4])\n", + "b = np.array([2, 8, -1, 7])\n", + "np.add(a, b) # equivalent to a + b" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([False, False, True, False])" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.greater(a, b) # equivalent to a > b" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2, 8, 3, 7])" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.maximum(a, b)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1., 2., -3., 4.])" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.copysign(a, b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Array indexing\n", + "## One-dimensional arrays\n", + "One-dimensional NumPy arrays can be accessed more or less like regular python arrays:" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.array([1, 5, 3, 19, 13, 7, 3])\n", + "a[3]" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 3, 19, 13])" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2:5]" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 3, 19, 13, 7])" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2:-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 5])" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[:2]" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 3, 13, 3])" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2::2]" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 3, 7, 13, 19, 3, 5, 1])" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[::-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Of course, you can modify elements:" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 5, 3, 999, 13, 7, 3])" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[3]=999\n", + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also modify an `ndarray` slice:" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 5, 997, 998, 999, 7, 3])" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2:5] = [997, 998, 999]\n", + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Differences with regular python arrays\n", + "Contrary to regular python arrays, if you assign a single value to an `ndarray` slice, it is copied across the whole slice, thanks to broadcasting rules discussed above." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 5, -1, -1, -1, 7, 3])" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[2:5] = -1\n", + "a" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Also, you cannot grow or shrink `ndarray`s this way:" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "could not broadcast input array from shape (6,) into shape (3,)\n" + ] + } + ], + "source": [ + "try:\n", + " a[2:5] = [1,2,3,4,5,6] # too long\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You cannot delete elements either:" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cannot delete array elements\n" + ] + } + ], + "source": [ + "try:\n", + " del a[2:5]\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Last but not least, `ndarray` **slices are actually *views*** on the same data buffer. This means that if you create a slice and modify it, you are actually going to modify the original `ndarray` as well!" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 5, -1, 1000, -1, 7, 3])" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_slice = a[2:6]\n", + "a_slice[1] = 1000\n", + "a # the original array was modified!" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ -1, 2000, -1, 7])" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[3] = 2000\n", + "a_slice # similarly, modifying the original array modifies the slice!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want a copy of the data, you need to use the `copy` method:" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 5, -1, 2000, -1, 7, 3])" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "another_slice = a[2:6].copy()\n", + "another_slice[1] = 3000\n", + "a # the original array is untouched" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ -1, 3000, -1, 7])" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a[3] = 4000\n", + "another_slice # similarly, modifying the original array does not affect the slice copy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multidimensional arrays\n", + "Multidimensional arrays can be accessed in a similar way by providing an index or slice for each axis, separated by commas:" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],\n", + " [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n", + " [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],\n", + " [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]])" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b = np.arange(48).reshape(4, 12)\n", + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[1, 2] # row 1, col 2" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23])" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[1, :] # row 1, all columns" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 13, 25, 37])" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[:, 1] # all rows, column 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Caution**: note the subtle difference between these two expressions: " + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23])" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[1, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[1:2, :]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first expression returns row 1 as a 1D array of shape `(12,)`, while the second returns that same row as a 2D array of shape `(1, 12)`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fancy indexing\n", + "You may also specify a list of indices that you are interested in. This is referred to as *fancy indexing*." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2, 3, 4],\n", + " [26, 27, 28]])" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[(0,2), 2:5] # rows 0 and 2, columns 2 to 4 (5-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[11, 2, 11],\n", + " [23, 14, 23],\n", + " [35, 26, 35],\n", + " [47, 38, 47]])" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[:, (-1, 2, -1)] # all rows, columns -1 (last), 2 and -1 (again, and in this order)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you provide multiple index arrays, you get a 1D `ndarray` containing the values of the elements at the specified coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([41, 33, 37, 33])" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[(-1, 2, -1, 2), (5, 9, 1, 9)] # returns a 1D array with b[-1, 5], b[2, 9], b[-1, 1] and b[2, 9] (again)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Higher dimensions\n", + "Everything works just as well with higher dimensional arrays, but it's useful to look at a few examples:" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 1, 2, 3, 4, 5],\n", + " [ 6, 7, 8, 9, 10, 11]],\n", + "\n", + " [[12, 13, 14, 15, 16, 17],\n", + " [18, 19, 20, 21, 22, 23]],\n", + "\n", + " [[24, 25, 26, 27, 28, 29],\n", + " [30, 31, 32, 33, 34, 35]],\n", + "\n", + " [[36, 37, 38, 39, 40, 41],\n", + " [42, 43, 44, 45, 46, 47]]])" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = b.reshape(4,2,6)\n", + "c" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "34" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c[2, 1, 4] # matrix 2, row 1, col 4" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([27, 33])" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c[2, :, 3] # matrix 2, all rows, col 3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you omit coordinates for some axes, then all elements in these axes are returned:" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([30, 31, 32, 33, 34, 35])" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c[2, 1] # Return matrix 2, row 1, all columns. This is equivalent to c[2, 1, :]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ellipsis (`...`)\n", + "You may also write an ellipsis (`...`) to ask that all non-specified axes be entirely included." + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[24, 25, 26, 27, 28, 29],\n", + " [30, 31, 32, 33, 34, 35]])" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c[2, ...] # matrix 2, all rows, all columns. This is equivalent to c[2, :, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([30, 31, 32, 33, 34, 35])" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c[2, 1, ...] # matrix 2, row 1, all columns. This is equivalent to c[2, 1, :]" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([27, 33])" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c[2, ..., 3] # matrix 2, all rows, column 3. This is equivalent to c[2, :, 3]" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 3, 9],\n", + " [15, 21],\n", + " [27, 33],\n", + " [39, 45]])" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c[..., 3] # all matrices, all rows, column 3. This is equivalent to c[:, :, 3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Boolean indexing\n", + "You can also provide an `ndarray` of boolean values on one axis to specify the indices that you want to access." + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],\n", + " [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n", + " [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],\n", + " [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]])" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b = np.arange(48).reshape(4, 12)\n", + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],\n", + " [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35]])" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rows_on = np.array([True, False, True, False])\n", + "b[rows_on, :] # Rows 0 and 2, all columns. Equivalent to b[(0, 2), :]" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, 4, 7, 10],\n", + " [13, 16, 19, 22],\n", + " [25, 28, 31, 34],\n", + " [37, 40, 43, 46]])" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cols_on = np.array([False, True, False] * 4)\n", + "b[:, cols_on] # All rows, columns 1, 4, 7 and 10" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `np.ix_`\n", + "You cannot use boolean indexing this way on multiple axes, but you can work around this by using the `ix_` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, 4, 7, 10],\n", + " [25, 28, 31, 34]])" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[np.ix_(rows_on, cols_on)]" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([[0],\n", + " [2]]),\n", + " array([[ 1, 4, 7, 10]]))" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.ix_(rows_on, cols_on)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you use a boolean array that has the same shape as the `ndarray`, then you get in return a 1D array containing all the values that have `True` at their coordinate. This is generally used along with conditional operators:" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46])" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b[b % 3 == 1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Iterating\n", + "Iterating over `ndarray`s is very similar to iterating over regular python arrays. Note that iterating over multidimensional arrays is done with respect to the first axis." + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7],\n", + " [ 8, 9, 10, 11]],\n", + "\n", + " [[12, 13, 14, 15],\n", + " [16, 17, 18, 19],\n", + " [20, 21, 22, 23]]])" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "c = np.arange(24).reshape(2, 3, 4) # A 3D array (composed of two 3x4 matrices)\n", + "c" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Item:\n", + "[[ 0 1 2 3]\n", + " [ 4 5 6 7]\n", + " [ 8 9 10 11]]\n", + "Item:\n", + "[[12 13 14 15]\n", + " [16 17 18 19]\n", + " [20 21 22 23]]\n" + ] + } + ], + "source": [ + "for m in c:\n", + " print(\"Item:\")\n", + " print(m)" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Item:\n", + "[[ 0 1 2 3]\n", + " [ 4 5 6 7]\n", + " [ 8 9 10 11]]\n", + "Item:\n", + "[[12 13 14 15]\n", + " [16 17 18 19]\n", + " [20 21 22 23]]\n" + ] + } + ], + "source": [ + "for i in range(len(c)): # Note that len(c) == c.shape[0]\n", + " print(\"Item:\")\n", + " print(c[i])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to iterate on *all* elements in the `ndarray`, simply iterate over the `flat` attribute:" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Item: 0\n", + "Item: 1\n", + "Item: 2\n", + "Item: 3\n", + "Item: 4\n", + "Item: 5\n", + "Item: 6\n", + "Item: 7\n", + "Item: 8\n", + "Item: 9\n", + "Item: 10\n", + "Item: 11\n", + "Item: 12\n", + "Item: 13\n", + "Item: 14\n", + "Item: 15\n", + "Item: 16\n", + "Item: 17\n", + "Item: 18\n", + "Item: 19\n", + "Item: 20\n", + "Item: 21\n", + "Item: 22\n", + "Item: 23\n" + ] + } + ], + "source": [ + "for i in c.flat:\n", + " print(\"Item:\", i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Stacking arrays\n", + "It is often useful to stack together different arrays. NumPy offers several functions to do just that. Let's start by creating a few arrays." + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., 1.],\n", + " [1., 1., 1., 1.],\n", + " [1., 1., 1., 1.]])" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q1 = np.full((3,4), 1.0)\n", + "q1" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2., 2., 2., 2.],\n", + " [2., 2., 2., 2.],\n", + " [2., 2., 2., 2.],\n", + " [2., 2., 2., 2.]])" + ] + }, + "execution_count": 107, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q2 = np.full((4,4), 2.0)\n", + "q2" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[3., 3., 3., 3.],\n", + " [3., 3., 3., 3.],\n", + " [3., 3., 3., 3.]])" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q3 = np.full((3,4), 3.0)\n", + "q3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `vstack`\n", + "Now let's stack them vertically using `vstack`:" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., 1.],\n", + " [1., 1., 1., 1.],\n", + " [1., 1., 1., 1.],\n", + " [2., 2., 2., 2.],\n", + " [2., 2., 2., 2.],\n", + " [2., 2., 2., 2.],\n", + " [2., 2., 2., 2.],\n", + " [3., 3., 3., 3.],\n", + " [3., 3., 3., 3.],\n", + " [3., 3., 3., 3.]])" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q4 = np.vstack((q1, q2, q3))\n", + "q4" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10, 4)" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q4.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It was possible because q1, q2 and q3 all have the same shape (except for the vertical axis, but that's ok since we are stacking on that axis).\n", + "\n", + "## `hstack`\n", + "We can also stack arrays horizontally using `hstack`:" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., 1., 3., 3., 3., 3.],\n", + " [1., 1., 1., 1., 3., 3., 3., 3.],\n", + " [1., 1., 1., 1., 3., 3., 3., 3.]])" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q5 = np.hstack((q1, q3))\n", + "q5" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 8)" + ] + }, + "execution_count": 112, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q5.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is possible because q1 and q3 both have 3 rows. But since q2 has 4 rows, it cannot be stacked horizontally with q1 and q3:" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "all the input array dimensions for the concatenation axis must match exactly, but along dimension 0, the array at index 0 has size 3 and the array at index 1 has size 4\n" + ] + } + ], + "source": [ + "try:\n", + " q5 = np.hstack((q1, q2, q3))\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `concatenate`\n", + "The `concatenate` function stacks arrays along any given existing axis." + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., 1.],\n", + " [1., 1., 1., 1.],\n", + " [1., 1., 1., 1.],\n", + " [2., 2., 2., 2.],\n", + " [2., 2., 2., 2.],\n", + " [2., 2., 2., 2.],\n", + " [2., 2., 2., 2.],\n", + " [3., 3., 3., 3.],\n", + " [3., 3., 3., 3.],\n", + " [3., 3., 3., 3.]])" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q7 = np.concatenate((q1, q2, q3), axis=0) # Equivalent to vstack\n", + "q7" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10, 4)" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q7.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you might guess, `hstack` is equivalent to calling `concatenate` with `axis=1`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## `stack`\n", + "The `stack` function stacks arrays along a new axis. All arrays have to have the same shape." + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[1., 1., 1., 1.],\n", + " [1., 1., 1., 1.],\n", + " [1., 1., 1., 1.]],\n", + "\n", + " [[3., 3., 3., 3.],\n", + " [3., 3., 3., 3.],\n", + " [3., 3., 3., 3.]]])" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q8 = np.stack((q1, q3))\n", + "q8" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 3, 4)" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q8.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Splitting arrays\n", + "Splitting is the opposite of stacking. For example, let's use the `vsplit` function to split a matrix vertically.\n", + "\n", + "First let's create a 6x4 matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7],\n", + " [ 8, 9, 10, 11],\n", + " [12, 13, 14, 15],\n", + " [16, 17, 18, 19],\n", + " [20, 21, 22, 23]])" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r = np.arange(24).reshape(6,4)\n", + "r" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's split it in three equal parts, vertically:" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 1, 2, 3],\n", + " [4, 5, 6, 7]])" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r1, r2, r3 = np.vsplit(r, 3)\n", + "r1" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 8, 9, 10, 11],\n", + " [12, 13, 14, 15]])" + ] + }, + "execution_count": 120, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r2" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[16, 17, 18, 19],\n", + " [20, 21, 22, 23]])" + ] + }, + "execution_count": 121, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is also a `split` function which splits an array along any given axis. Calling `vsplit` is equivalent to calling `split` with `axis=0`. There is also an `hsplit` function, equivalent to calling `split` with `axis=1`:" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1],\n", + " [ 4, 5],\n", + " [ 8, 9],\n", + " [12, 13],\n", + " [16, 17],\n", + " [20, 21]])" + ] + }, + "execution_count": 122, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r4, r5 = np.hsplit(r, 2)\n", + "r4" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2, 3],\n", + " [ 6, 7],\n", + " [10, 11],\n", + " [14, 15],\n", + " [18, 19],\n", + " [22, 23]])" + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Transposing arrays\n", + "The `transpose` method creates a new view on an `ndarray`'s data, with axes permuted in the given order.\n", + "\n", + "For example, let's create a 3D array:" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 1, 2],\n", + " [ 3, 4, 5]],\n", + "\n", + " [[ 6, 7, 8],\n", + " [ 9, 10, 11]],\n", + "\n", + " [[12, 13, 14],\n", + " [15, 16, 17]],\n", + "\n", + " [[18, 19, 20],\n", + " [21, 22, 23]]])" + ] + }, + "execution_count": 124, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t = np.arange(24).reshape(4,2,3)\n", + "t" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's create an `ndarray` such that the axes `0, 1, 2` (depth, height, width) are re-ordered to `1, 2, 0` (depth→width, height→depth, width→height):" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 6, 12, 18],\n", + " [ 1, 7, 13, 19],\n", + " [ 2, 8, 14, 20]],\n", + "\n", + " [[ 3, 9, 15, 21],\n", + " [ 4, 10, 16, 22],\n", + " [ 5, 11, 17, 23]]])" + ] + }, + "execution_count": 125, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t1 = t.transpose((1,2,0))\n", + "t1" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 3, 4)" + ] + }, + "execution_count": 126, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t1.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, `transpose` reverses the order of the dimensions:" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 6, 12, 18],\n", + " [ 3, 9, 15, 21]],\n", + "\n", + " [[ 1, 7, 13, 19],\n", + " [ 4, 10, 16, 22]],\n", + "\n", + " [[ 2, 8, 14, 20],\n", + " [ 5, 11, 17, 23]]])" + ] + }, + "execution_count": 127, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t2 = t.transpose() # equivalent to t.transpose((2, 1, 0))\n", + "t2" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 2, 4)" + ] + }, + "execution_count": 128, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t2.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "NumPy provides a convenience function `swapaxes` to swap two axes. For example, let's create a new view of `t` with depth and height swapped:" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 1, 2],\n", + " [ 6, 7, 8],\n", + " [12, 13, 14],\n", + " [18, 19, 20]],\n", + "\n", + " [[ 3, 4, 5],\n", + " [ 9, 10, 11],\n", + " [15, 16, 17],\n", + " [21, 22, 23]]])" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t3 = t.swapaxes(0,1) # equivalent to t.transpose((1, 0, 2))\n", + "t3" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 4, 3)" + ] + }, + "execution_count": 130, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t3.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Linear algebra\n", + "NumPy 2D arrays can be used to represent matrices efficiently in python. We will just quickly go through some of the main matrix operations available. For more details about Linear Algebra, vectors and matrices, go through the [Linear Algebra tutorial](math_linear_algebra.ipynb).\n", + "\n", + "## Matrix transpose\n", + "The `T` attribute is equivalent to calling `transpose()` when the rank is ≥2:" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 1, 2, 3, 4],\n", + " [5, 6, 7, 8, 9]])" + ] + }, + "execution_count": 131, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m1 = np.arange(10).reshape(2,5)\n", + "m1" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 5],\n", + " [1, 6],\n", + " [2, 7],\n", + " [3, 8],\n", + " [4, 9]])" + ] + }, + "execution_count": 132, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m1.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `T` attribute has no effect on rank 0 (empty) or rank 1 arrays:" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 2, 3, 4])" + ] + }, + "execution_count": 133, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m2 = np.arange(5)\n", + "m2" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 2, 3, 4])" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m2.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can get the desired transposition by first reshaping the 1D array to a single-row matrix (2D):" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 1, 2, 3, 4]])" + ] + }, + "execution_count": 135, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m2r = m2.reshape(1,5)\n", + "m2r" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0],\n", + " [1],\n", + " [2],\n", + " [3],\n", + " [4]])" + ] + }, + "execution_count": 136, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m2r.T" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Matrix multiplication\n", + "Let's create two matrices and execute a [matrix multiplication](https://en.wikipedia.org/wiki/Matrix_multiplication) using the `dot()` method." + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 1, 2, 3, 4],\n", + " [5, 6, 7, 8, 9]])" + ] + }, + "execution_count": 137, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n1 = np.arange(10).reshape(2, 5)\n", + "n1" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2],\n", + " [ 3, 4, 5],\n", + " [ 6, 7, 8],\n", + " [ 9, 10, 11],\n", + " [12, 13, 14]])" + ] + }, + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n2 = np.arange(15).reshape(5,3)\n", + "n2" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 90, 100, 110],\n", + " [240, 275, 310]])" + ] + }, + "execution_count": 139, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n1.dot(n2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Caution**: as mentioned previously, `n1*n2` is *not* a matrix multiplication, it is an elementwise product (also called a [Hadamard product](https://en.wikipedia.org/wiki/Hadamard_product_(matrices)))." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Matrix inverse and pseudo-inverse\n", + "Many of the linear algebra functions are available in the `numpy.linalg` module, in particular the `inv` function to compute a square matrix's inverse:" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, 2, 3],\n", + " [ 5, 7, 11],\n", + " [21, 29, 31]])" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy.linalg as linalg\n", + "\n", + "m3 = np.array([[1,2,3],[5,7,11],[21,29,31]])\n", + "m3" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2.31818182, 0.56818182, 0.02272727],\n", + " [ 1.72727273, -0.72727273, 0.09090909],\n", + " [-0.04545455, 0.29545455, -0.06818182]])" + ] + }, + "execution_count": 141, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "linalg.inv(m3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also compute the [pseudoinverse](https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_pseudoinverse) using `pinv`:" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-2.31818182, 0.56818182, 0.02272727],\n", + " [ 1.72727273, -0.72727273, 0.09090909],\n", + " [-0.04545455, 0.29545455, -0.06818182]])" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "linalg.pinv(m3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Identity matrix\n", + "The product of a matrix by its inverse returns the identity matrix (with small floating point errors):" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.00000000e+00, -1.66533454e-16, 0.00000000e+00],\n", + " [ 6.31439345e-16, 1.00000000e+00, -1.38777878e-16],\n", + " [ 5.21110932e-15, -2.38697950e-15, 1.00000000e+00]])" + ] + }, + "execution_count": 143, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m3.dot(linalg.inv(m3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can create an identity matrix of size NxN by calling `eye(N)` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 0.],\n", + " [0., 1., 0.],\n", + " [0., 0., 1.]])" + ] + }, + "execution_count": 144, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.eye(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## QR decomposition\n", + "The `qr` function computes the [QR decomposition](https://en.wikipedia.org/wiki/QR_decomposition) of a matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.04627448, 0.98786672, 0.14824986],\n", + " [-0.23137241, 0.13377362, -0.96362411],\n", + " [-0.97176411, -0.07889213, 0.22237479]])" + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q, r = linalg.qr(m3)\n", + "q" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-21.61018278, -29.89331494, -32.80860727],\n", + " [ 0. , 0.62427688, 1.9894538 ],\n", + " [ 0. , 0. , -3.26149699]])" + ] + }, + "execution_count": 146, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1., 2., 3.],\n", + " [ 5., 7., 11.],\n", + " [21., 29., 31.]])" + ] + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q.dot(r) # q.r equals m3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Determinant\n", + "The `det` function computes the [matrix determinant](https://en.wikipedia.org/wiki/Determinant):" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "43.99999999999997" + ] + }, + "execution_count": 148, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "linalg.det(m3) # Computes the matrix determinant" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Eigenvalues and eigenvectors\n", + "The `eig` function computes the [eigenvalues and eigenvectors](https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors) of a square matrix:" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([42.26600592, -0.35798416, -2.90802176])" + ] + }, + "execution_count": 149, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eigenvalues, eigenvectors = linalg.eig(m3)\n", + "eigenvalues # λ" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.08381182, -0.76283526, -0.18913107],\n", + " [-0.3075286 , 0.64133975, -0.6853186 ],\n", + " [-0.94784057, -0.08225377, 0.70325518]])" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "eigenvectors # v" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 6.66133815e-15, 1.66533454e-15, -3.10862447e-15],\n", + " [ 7.10542736e-15, 5.16253706e-15, -5.32907052e-15],\n", + " [ 3.55271368e-14, 4.94743135e-15, -9.76996262e-15]])" + ] + }, + "execution_count": 151, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m3.dot(eigenvectors) - eigenvalues * eigenvectors # m3.v - λ*v = 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Singular Value Decomposition\n", + "The `svd` function takes a matrix and returns its [singular value decomposition](https://en.wikipedia.org/wiki/Singular_value_decomposition):" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 0, 0, 0, 2],\n", + " [0, 0, 3, 0, 0],\n", + " [0, 0, 0, 0, 0],\n", + " [0, 2, 0, 0, 0]])" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m4 = np.array([[1,0,0,0,2], [0,0,3,0,0], [0,0,0,0,0], [0,2,0,0,0]])\n", + "m4" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0., 1., 0., 0.],\n", + " [ 1., 0., 0., 0.],\n", + " [ 0., 0., 0., -1.],\n", + " [ 0., 0., 1., 0.]])" + ] + }, + "execution_count": 153, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "U, S_diag, V = linalg.svd(m4)\n", + "U" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([3. , 2.23606798, 2. , 0. ])" + ] + }, + "execution_count": 154, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S_diag" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `svd` function just returns the values in the diagonal of Σ, but we want the full Σ matrix, so let's create it:" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[3. , 0. , 0. , 0. , 0. ],\n", + " [0. , 2.23606798, 0. , 0. , 0. ],\n", + " [0. , 0. , 2. , 0. , 0. ],\n", + " [0. , 0. , 0. , 0. , 0. ]])" + ] + }, + "execution_count": 155, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S = np.zeros((4, 5))\n", + "S[np.diag_indices(4)] = S_diag\n", + "S # Σ" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0. , 0. , 1. , -0. , 0. ],\n", + " [ 0.4472136 , 0. , 0. , 0. , 0.89442719],\n", + " [-0. , 1. , 0. , -0. , 0. ],\n", + " [ 0. , 0. , 0. , 1. , 0. ],\n", + " [-0.89442719, 0. , 0. , 0. , 0.4472136 ]])" + ] + }, + "execution_count": 156, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "V" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 0., 0., 2.],\n", + " [0., 0., 3., 0., 0.],\n", + " [0., 0., 0., 0., 0.],\n", + " [0., 2., 0., 0., 0.]])" + ] + }, + "execution_count": 157, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "U.dot(S).dot(V) # U.Σ.V == m4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Diagonal and trace" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 7, 31])" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.diag(m3) # the values in the diagonal of m3 (top left to bottom right)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "39" + ] + }, + "execution_count": 159, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m3.trace() # equivalent to np.diag(m3).sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solving a system of linear scalar equations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `solve` function solves a system of linear scalar equations, such as:\n", + "\n", + "* $2x + 6y = 6$\n", + "* $5x + 3y = -9$" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-3., 2.])" + ] + }, + "execution_count": 160, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "coeffs = np.array([[2, 6], [5, 3]])\n", + "depvars = np.array([6, -9])\n", + "solution = linalg.solve(coeffs, depvars)\n", + "solution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check the solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([ 6., -9.]), array([ 6, -9]))" + ] + }, + "execution_count": 161, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "coeffs.dot(solution), depvars # yep, it's the same" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looks good! Another way to check the solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 162, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.allclose(coeffs.dot(solution), depvars)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Vectorization\n", + "Instead of executing operations on individual array items, one at a time, your code is much more efficient if you try to stick to array operations. This is called *vectorization*. This way, you can benefit from NumPy's many optimizations.\n", + "\n", + "For example, let's say we want to generate a 768x1024 array based on the formula $sin(xy/40.5)$. A **bad** option would be to do the math in python using nested loops:" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "data = np.empty((768, 1024))\n", + "for y in range(768):\n", + " for x in range(1024):\n", + " data[y, x] = math.sin(x * y / 40.5) # BAD! Very inefficient." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sure, this works, but it's terribly inefficient since the loops are taking place in pure python. Let's vectorize this algorithm. First, we will use NumPy's `meshgrid` function which generates coordinate matrices from coordinate vectors." + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, ..., 1021, 1022, 1023],\n", + " [ 0, 1, 2, ..., 1021, 1022, 1023],\n", + " [ 0, 1, 2, ..., 1021, 1022, 1023],\n", + " ...,\n", + " [ 0, 1, 2, ..., 1021, 1022, 1023],\n", + " [ 0, 1, 2, ..., 1021, 1022, 1023],\n", + " [ 0, 1, 2, ..., 1021, 1022, 1023]])" + ] + }, + "execution_count": 164, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_coords = np.arange(0, 1024) # [0, 1, 2, ..., 1023]\n", + "y_coords = np.arange(0, 768) # [0, 1, 2, ..., 767]\n", + "X, Y = np.meshgrid(x_coords, y_coords)\n", + "X" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 0, 0, ..., 0, 0, 0],\n", + " [ 1, 1, 1, ..., 1, 1, 1],\n", + " [ 2, 2, 2, ..., 2, 2, 2],\n", + " ...,\n", + " [765, 765, 765, ..., 765, 765, 765],\n", + " [766, 766, 766, ..., 766, 766, 766],\n", + " [767, 767, 767, ..., 767, 767, 767]])" + ] + }, + "execution_count": 165, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, both `X` and `Y` are 768x1024 arrays, and all values in `X` correspond to the horizontal coordinate, while all values in `Y` correspond to the vertical coordinate.\n", + "\n", + "Now we can simply compute the result using array operations:" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": {}, + "outputs": [], + "source": [ + "data = np.sin(X * Y / 40.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can plot this data using matplotlib's `imshow` function (see the [matplotlib tutorial](tools_matplotlib.ipynb))." + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 504x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig = plt.figure(1, figsize=(7, 6))\n", + "plt.imshow(data, cmap=\"hot\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Saving and loading\n", + "NumPy makes it easy to save and load `ndarray`s in binary or text format.\n", + "\n", + "## Binary `.npy` format\n", + "Let's create a random array and save it." + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.29589295, 0.74421264, 0.01108453],\n", + " [0.00981294, 0.07941431, 0.10770867]])" + ] + }, + "execution_count": 168, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = np.random.rand(2,3)\n", + "a" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [], + "source": [ + "np.save(\"my_array\", a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Done! Since the file name contains no file extension, NumPy automatically added `.npy`. Let's take a peek at the file content:" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "b\"\\x93NUMPY\\x01\\x00v\\x00{'descr': '<f8', 'fortran_order': False, 'shape': (2, 3), } \\n\\\\\\x9cd\\xfd\\xe8\\xef\\xd2? \\xda^\\x07\\x97\\xd0\\xe7?@\\x7f\\xb4\\xf8|\\xb3\\x86?\\x00m\\x1d\\x18\\xce\\x18\\x84?\\xa0\\xf7\\xa6\\x1c\\x7fT\\xb4?\\xf0\\xe7\\xf5\\x90\\xcb\\x92\\xbb?\"" + ] + }, + "execution_count": 170, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with open(\"my_array.npy\", \"rb\") as f:\n", + " content = f.read()\n", + "\n", + "content" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To load this file into a NumPy array, simply call `load`:" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.29589295, 0.74421264, 0.01108453],\n", + " [0.00981294, 0.07941431, 0.10770867]])" + ] + }, + "execution_count": 171, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_loaded = np.load(\"my_array.npy\")\n", + "a_loaded" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Text format\n", + "Let's try saving the array in text format:" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\"my_array.csv\", a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's look at the file content:" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.958929514447328213e-01 7.442126411395442176e-01 1.108453401553755047e-02\n", + "9.812936888627721288e-03 7.941431474225035814e-02 1.077086666972772999e-01\n", + "\n" + ] + } + ], + "source": [ + "with open(\"my_array.csv\", \"rt\") as f:\n", + " print(f.read())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a CSV file with tabs as delimiters. You can set a different delimiter:" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "metadata": {}, + "outputs": [], + "source": [ + "np.savetxt(\"my_array.csv\", a, delimiter=\",\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To load this file, just use `loadtxt`:" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.29589295, 0.74421264, 0.01108453],\n", + " [0.00981294, 0.07941431, 0.10770867]])" + ] + }, + "execution_count": 175, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_loaded = np.loadtxt(\"my_array.csv\", delimiter=\",\")\n", + "a_loaded" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Zipped `.npz` format\n", + "It is also possible to save multiple arrays in one zipped file:" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[ 0, 1, 2, 3],\n", + " [ 4, 5, 6, 7],\n", + " [ 8, 9, 10, 11]],\n", + "\n", + " [[12, 13, 14, 15],\n", + " [16, 17, 18, 19],\n", + " [20, 21, 22, 23]]], dtype=uint8)" + ] + }, + "execution_count": 176, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b = np.arange(24, dtype=np.uint8).reshape(2, 3, 4)\n", + "b" + ] + }, + { + "cell_type": "code", + "execution_count": 177, + "metadata": {}, + "outputs": [], + "source": [ + "np.savez(\"my_arrays\", my_a=a, my_b=b)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again, let's take a peek at the file content. Note that the `.npz` file extension was automatically added." + ] + }, + { + "cell_type": "code", + "execution_count": 178, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'b\"PK\\\\x03\\\\x04\\\\x14\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00!\\\\x00\\\\xf1\\\\xe2\\\\x90\\\\xa8\\\\xb0\\\\x00\\\\x00\\\\x00\\\\xb0\\\\x00\\\\x00\\\\x00\\\\x08\\\\x00\\\\x14\\\\x00my_a.npy\\\\x01\\\\x00\\\\x10\\\\x00\\\\xb0\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\xb0\\\\x00\\\\x0[...]'" + ] + }, + "execution_count": 178, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "with open(\"my_arrays.npz\", \"rb\") as f:\n", + " content = f.read()\n", + "\n", + "repr(content)[:180] + \"[...]\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You then load this file like so:" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<numpy.lib.npyio.NpzFile at 0x127ebe1f0>" + ] + }, + "execution_count": 179, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_arrays = np.load(\"my_arrays.npz\")\n", + "my_arrays" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a dict-like object which loads the arrays lazily:" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "KeysView(<numpy.lib.npyio.NpzFile object at 0x127ebe1f0>)" + ] + }, + "execution_count": 180, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_arrays.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.29589295, 0.74421264, 0.01108453],\n", + " [0.00981294, 0.07941431, 0.10770867]])" + ] + }, + "execution_count": 181, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_arrays[\"my_a\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# What's next?\n", + "Now you know all the fundamentals of NumPy, but there are many more options available. The best way to learn more is to experiment with NumPy, and go through the excellent [reference documentation](https://numpy.org/doc/stable/reference/index.html) to find more functions and features you may be interested in." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + }, + "toc": { + "toc_cell": false, + "toc_number_sections": true, + "toc_section_display": "block", + "toc_threshold": 6, + "toc_window_display": false + }, + "toc_position": { + "height": "677px", + "left": "1195.02px", + "right": "20px", + "top": "78px", + "width": "238px" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} |