{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "STAT 479: Machine Learning (Fall 2019) \n", "Instructor: Sebastian Raschka (sraschka@wisc.edu) \n", "Course website: http://pages.stat.wisc.edu/~sraschka/teaching/stat479-fs2019/" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# L04: Scientific Computing in Python" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%load_ext watermark" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sebastian Raschka \n", "\n", "CPython 3.7.3\n", "IPython 7.7.0\n", "\n", "numpy 1.16.4\n", "scipy 1.3.1\n", "matplotlib 3.1.1\n" ] } ], "source": [ "%watermark -v -a 'Sebastian Raschka' -p numpy,scipy,matplotlib" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## NumPy -- Working with Numerical Arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Introduction to NumPy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This section offers a quick tour of the NumPy library for working with multi-dimensional arrays in Python. NumPy (short for Numerical Python) was created by Travis Oliphant in 2005, by merging Numarray into Numeric. Since then, the open source NumPy library has evolved into an essential library for scientific computing in Python and has become a building block of many other scientific libraries, such as SciPy, Scikit-learn, Pandas, and others.\n", "What makes NumPy so particularly attractive to the scientific community is that it provides a convenient Python interface for working with multi-dimensional array data structures efficiently; the NumPy array data structure is also called `ndarray`, which is short for *n*-dimensional array. \n", "\n", "In addition to being mostly implemented in C and using Python as a \"glue language,\" the main reason why NumPy is so efficient for numerical computations is that NumPy arrays use contiguous blocks of memory that can be efficiently cached by the CPU. In contrast, Python lists are arrays of pointers to objects in random locations in memory, which cannot be easily cached and come with a more expensive memory-look-up. However, the computational efficiency and low-memory footprint come at a cost: NumPy arrays have a fixed size and are homogeneous, which means that all elements must have the same type. Homogenous `ndarray` objects have the advantage that NumPy can carry out operations using efficient C loops and avoid expensive type checks and other overheads of the Python API. While adding and removing elements from the end of a Python list is very efficient, altering the size of a NumPy array is very expensive since it requires to create a new array and carry over the contents of the old array that we want to expand or shrink. \n", "\n", "Besides being more efficient for numerical computations than native Python code, NumPy can also be more elegant and readable due to vectorized operations and broadcasting, which are features that we will explore in this lecture. While this material should be sufficient to follow the code examples in this course." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### N-dimensional Arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy is built around [`ndarrays`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html) objects, which are high-performance multi-dimensional array data structures. Intuitively, we can think of a one-dimensional NumPy array as a data structure to represent a vector of elements -- you may think of it as a fixed-size Python list where all elements share the same type. Similarly, we can think of a two-dimensional array as a data structure to represent a matrix or a Python list of lists. While NumPy arrays can have up to 32 dimensions if it was compiled without alterations to the source code, we will focus on lower-dimensional arrays for the purpose of illustration in this introduction.\n", "\n", "Now, let us get started with NumPy by calling the `array` function to create a two-dimensional NumPy array, consisting of two rows and three columns, from a list of lists:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "\n", "\n", "lst = [[1, 2, 3], [4, 5, 6]]\n", "ary2d = np.array(lst)\n", "ary2d" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](./images/numpy-intro/array_1.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "By default, NumPy infers the type of the array upon construction. Since we passed Python integers to the array, the `ndarray` object `ary2d` should be of type `int64` on a 64-bit machine, which we can confirm by accessing the `dtype` attribute:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dtype('int64')" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary2d.dtype" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want to construct NumPy arrays of different types, we can pass an argument to the `dtype` parameter of the `array` function, for example `np.int32` to create 32-bit arrays. For a full list of supported data types, please refer to the official [NumPy documentation](https://docs.scipy.org/doc/numpy/user/basics.types.html). Once an array has been constructed, we can downcast or recast its type via the `astype` method as shown in the following example:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1., 2., 3.],\n", " [4., 5., 6.]], dtype=float32)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "float32_ary = ary2d.astype(np.float32)\n", "float32_ary" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dtype('float32')" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "float32_ary.dtype" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The code snippet above returned `8`, which means that each element in the array (remember that `ndarray`s are homogeneous) takes up 8 bytes in memory. This result makes sense since the array `ary2d` has type `int64` (64-bit integer), which we determined earlier, and 8 bits equals 1 byte. (Note that `'int64'` is just a shorthand for `np.int64`.)\n", "\n", "To return the number of elements in an array, we can use the `size` attribute, as shown below:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary2d.size" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And the number of dimensions of our array (Intuitively, you may think of *dimensions* as the *rank* of a tensor) can be obtained via the `ndim` attribute:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary2d.ndim" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we are interested in the number of elements along each array dimension (in the context of NumPy arrays, we may also refer to them as *axes*), we can access the `shape` attribute as shown below:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 3)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary2d.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `shape` is always a tuple; in the code example above, the two-dimensional `ary` object has two *rows* and *three* columns, `(2, 3)`, if we think of it as a matrix representation.\n", "\n", "Similarly, the `shape` of the one-dimensional array only contains a single value:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3,)" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.array([1, 2, 3]).shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Array Construction Routines" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This section provides a non-comprehensive list of array construction functions. Simple yet useful functions exist to construct arrays containing ones or zeros:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1., 1., 1.],\n", " [1., 1., 1.],\n", " [1., 1., 1.]])" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.ones((3, 3))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[0., 0., 0.],\n", " [0., 0., 0.],\n", " [0., 0., 0.]])" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.zeros((3, 3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Creating arrays of ones or zeros can also be useful as placeholder arrays, in cases where we do not want to use the initial values for computations but want to fill it with other values right away. If we do not need the initial values (for instance, `'0.'` or `'1.'`), there is also `numpy.empty`, which follows the same syntax as `numpy.ones` and `np.zeros`. However, instead of filling the array with a particular value, the `empty` function creates the array with non-sensical values from memory. We can think of `zeros` as a function that creates the array via `empty` and then sets all its values to `0.` -- in practice, a difference in speed is not noticeable, though. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy also comes with functions to create identity matrices and diagonal matrices as `ndarrays` that can be useful in the context of linear algebra -- a topic that we will explore later in this section. " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1., 0., 0.],\n", " [0., 1., 0.],\n", " [0., 0., 1.]])" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.eye(3)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[3, 0, 0],\n", " [0, 3, 0],\n", " [0, 0, 3]])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.diag((3, 3, 3))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lastly, I want to mention two very useful functions for creating sequences of numbers within a specified range, namely, `arange` and `linspace`. NumPy's `arange` function follows the same syntax as Python's `range` objects: If two arguments are provided, the first argument represents the start value and the second value defines the stop value of a half-open interval:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4., 5., 6., 7., 8., 9.])" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(4., 10.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that `arange` also performs type inference similar to the `array` function. If we only provide a single function argument, the range object treats this number as the endpoint of the interval and starts at 0:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4])" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similar to Python's `range`, a third argument can be provided to define the *step* (the default step size is 1). For example, we can obtain an array of all uneven values between one and ten as follows:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1., 3., 5., 7., 9.])" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.arange(1., 11., 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `linspace` function is especially useful if we want to create a particular number of evenly spaced values in a specified half-open interval:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.25, 0.5 , 0.75, 1. ])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.linspace(0., 1., num=5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Array Indexing" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this section, we will go over the basics of retrieving NumPy array elements via different indexing methods. Simple NumPy indexing and slicing works similar to Python lists, which we will demonstrate in the following code snippet, where we retrieve the first element of a one-dimensional array:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([1, 2, 3])\n", "ary[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Also, the same Python semantics apply to slicing operations. The following example shows how to fetch the first two elements in `ary`:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[:2] # equivalent to ary[0:2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we work with arrays that have more than one dimension or axis, we separate our indexing or slicing operations by commas as shown in the series of examples below:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3],\n", " [4, 5, 6]])\n", "\n", "ary[0, 0] # upper left" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[-1, -1] # lower right" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[0, 1] # first row, second column" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](./images/numpy-intro/array_2.png)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[0] # entire first row" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 4])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[:, 0] # entire first column" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [4, 5]])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[:, :2] # first two columns" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[0, 0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Array Math and Universal Functions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the previous sections, you learned how to create NumPy arrays and how to access different elements in an array. It is about time that we introduce one of the core features of NumPy that makes working with `ndarray` so efficient and convenient: vectorization. While we typically use for-loops if we want to perform arithmetic operations on sequence-like objects, NumPy provides vectorized wrappers for performing element-wise operations implicitly via so-called *ufuncs* -- short for universal functions.\n", "\n", "As of this writing, there are more than 60 ufuncs available in NumPy; ufuncs are implemented in compiled C code and very fast and efficient compared to vanilla Python. In this section, we will take a look at the most commonly used ufuncs, and I recommend you to check out the [official documentation](https://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs) for a complete list.\n", "\n", "To provide an example of a simple ufunc for element-wise addition, consider the following example, where we add a scalar (here: 1) to each element in a nested Python list:" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[[2, 3, 4], [5, 6, 7]]" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lst = [[1, 2, 3], [4, 5, 6]]\n", "\n", "for row_idx, row_val in enumerate(lst):\n", " for col_idx, col_val in enumerate(row_val):\n", " lst[row_idx][col_idx] += 1\n", "lst" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This for-loop approach is very verbose, and we could achieve the same goal more elegantly using list comprehensions:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[[2, 3, 4], [5, 6, 7]]" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lst = [[1, 2, 3], [4, 5, 6]]\n", "[[cell + 1 for cell in row] for row in lst]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can accomplish the same using NumPy's ufunc for element-wise scalar addition as shown below:" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[2, 3, 4],\n", " [5, 6, 7]])" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3], [4, 5, 6]])\n", "ary = np.add(ary, 1)\n", "ary" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The ufuncs for basic arithmetic operations are `add`, `subtract`, `divide`, `multiply`, and `exp` (exponential). However, NumPy uses operator overloading so that we can use mathematical operators (`+`, `-`, `/`, `*`, and `**`) directly:" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[3, 4, 5],\n", " [6, 7, 8]])" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary + 1" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 4, 9, 16],\n", " [25, 36, 49]])" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary**2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Above, we have seen examples of *binary* ufuncs, which are ufuncs that take two arguments as an input. In addition, NumPy implements several useful *unary* ufuncs, such as `log` (natural logarithm), `log10` (base-10 logarithm), and `sqrt` (square root).\n", "\n", "Often, we want to compute the sum or product of array element along a given axis. For this purpose, we can use a ufunc's `reduce` operation. By default, `reduce` applies an operation along the first axis (`axis=0`). In the case of a two-dimensional array, we can think of the first axis as the rows of a matrix. Thus, adding up elements along rows yields the column sums of that matrix as shown below:" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([5, 7, 9])" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3], \n", " [4, 5, 6]])\n", "\n", "np.add.reduce(ary) # column sumns" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To compute the row sums of the array above, we can specify `axis=1`:" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 6, 15])" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.add.reduce(ary, axis=1) # row sums" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While it can be more intuitive to use `reduce` as a more general operation, NumPy also provides shorthands for specific operations such as `product` and `sum`. For example, `sum(axis=0)` is equivalent to `add.reduce`:" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([5, 7, 9])" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary.sum(axis=0) # column sums" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](./images/numpy-intro/ufunc.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a word of caution, keep in mind that `product` and `sum` both compute the product or sum of the entire array if we do not specify an axis:" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "21" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary.sum()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Other useful unary ufuncs are:\n", " \n", "- `np.mean` (computes arithmetic average)\n", "- `np.std` (computes the standard deviation)\n", "- `np.var` (computes variance)\n", "- `np.sort` (sorts an array)\n", "- `np.argsort` (returns indices that would sort an array)\n", "- `np.min` (returns the minimum value of an array)\n", "- `np.max` (returns the maximum value of an array)\n", "- `np.argmin` (returns the index of the minimum value)\n", "- `np.argmax` (returns the index of the maximum value)\n", "- `np.array_equal` (checks if two arrays have the same shape and elements)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Broadcasting" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A topic we glanced over in the previous section is broadcasting. Broadcasting allows us to perform vectorized operations between two arrays even if their dimensions do not match by creating implicit multidimensional grids. You already learned about ufuncs in the previous section where we performed element-wise addition between a scalar and a multidimensional array, which is just one example of broadcasting. \n", "\n", "\n", "![](./images/numpy-intro/broadcasting-1.png)\n", "\n", "Naturally, we can also perform element-wise operations between arrays of equal dimensions:" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([5, 7, 9])" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary1 = np.array([1, 2, 3])\n", "ary2 = np.array([4, 5, 6])\n", "\n", "ary1 + ary2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In contrast to what we are used from linear algebra, we can also add arrays of different shapes. In the example above, we will add a one-dimensional to a two-dimensional array, where NumPy creates an implicit multidimensional grid from the one-dimensional array `ary1`:" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 5, 7, 9],\n", " [ 8, 10, 12]])" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary3 = np.array([[4, 5, 6], \n", " [7, 8, 9]])\n", "\n", "ary3 + ary1 # similarly, ary1 + ary3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](./images/numpy-intro/broadcasting-2.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Advanced Indexing -- Memory Views and Copies" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the previous sections, we have used basic indexing and slicing routines. It is important to note that basic integer-based indexing and slicing create so-called *views* of NumPy arrays in memory. Working with views can be highly desirable since it avoids making unnecessary copies of arrays to save memory resources. To illustrate the concept of memory views, let us walk through a simple example where we access the first row in an array, assign it to a variable, and modify that variable:" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[100, 101, 102],\n", " [ 4, 5, 6]])" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3],\n", " [4, 5, 6]])\n", "\n", "first_row = ary[0]\n", "first_row += 99\n", "ary" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we can see in the example above, changing the value of `first_row` also affected the original array. The reason for this is that `ary[0]` created a view of the first row in `ary`, and its elements were then incremented by 99. The same concept applies to slicing operations:" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[100, 101, 102],\n", " [ 4, 5, 6]])" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3],\n", " [4, 5, 6]])\n", "\n", "first_row = ary[:1]\n", "first_row += 99\n", "ary" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 101, 3],\n", " [ 4, 104, 6]])" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3],\n", " [4, 5, 6]])\n", "\n", "center_col = ary[:, 1]\n", "center_col += 99\n", "ary" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we are working with NumPy arrays, it is always important to be aware that **slicing creates views** -- sometimes it is desirable since it can speed up our code by avoiding to create unnecessary copies in memory. However, in certain scenarios we want force a copy of an array; we can do this via the `copy` method as shown below:" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3],\n", " [4, 5, 6]])\n", "\n", "second_row = ary[1].copy()\n", "second_row += 99\n", "ary" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In addition to basic single-integer indexing and slicing operations, NumPy supports advanced indexing routines called *fancy* indexing. Via fancy indexing, we can use tuple or list objects of non-contiguous integer indices to return desired array elements. Since fancy indexing can be performed with non-contiguous sequences, it cannot return a view -- a contiguous slice from memory. Thus, fancy indexing always returns a copy of an array -- it is important to keep that in mind. The following code snippets show some fancy indexing examples:" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 3],\n", " [4, 6]])" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3],\n", " [4, 5, 6]])\n", "\n", "ary[:, [0, 2]] # first and and last column" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "this_is_a_copy = ary[:, [0, 2]]\n", "this_is_a_copy += 99\n", "ary" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[3, 1],\n", " [6, 4]])" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[:, [2, 0]] # first and and last column" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we can also use Boolean masks for indexing -- that is, arrays of `True` and `False` values. Consider the following example, where we return all values in the array that are greater than 3:" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[False, False, False],\n", " [ True, True, True]])" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3],\n", " [4, 5, 6]])\n", "\n", "greater3_mask = ary > 3\n", "greater3_mask" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using these masks, we can select elements given our desired criteria:" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4, 5, 6])" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[greater3_mask]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also chain different selection criteria using the logical *and* operator '&' or the logical *or* operator '|'. The example below demonstrates how we can select array elements that are greater than 3 and divisible by 2:" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4, 6])" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[(ary > 3) & (ary % 2 == 0)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that indexing using Boolean arrays is also considered \"fancy indexing\" and thus returns a copy of the array." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Random Number Generators" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In machine learning and deep learning, we often have to generate arrays of random numbers -- for example, the initial values of our model parameters before optimization. NumPy has a `random` subpackage to create random numbers and samples from a variety of distributions conveniently. Again, I encourage you to browse through the more comprehensive [numpy.random documentation](https://docs.scipy.org/doc/numpy/reference/routines.random.html) for a more comprehensive list of functions for random sampling.\n", "\n", "To provide a brief overview of the pseudo-random number generators that we will use most commonly, let's start with drawing a random sample from a uniform distribution:" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.69646919, 0.28613933, 0.22685145])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.random.seed(123)\n", "np.random.rand(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the code snippet above, we first seeded NumPy's random number generator. Then, we drew three random samples from a uniform distribution via `random.rand` in the half-open interval [0, 1). I highly recommend the seeding step in practical applications as well as in research projects, since it ensures that our results are reproducible. If we run our code sequentially -- for example, if we execute a Python script -- it should be sufficient to seed the random number generator only once at the beginning to enforce reproducible outcomes between different runs. However, it is often useful to create separate `RandomState` objects for various parts of our code, so that we can test methods of functions reliably in unit tests. Working with multiple, separate `RandomState` objects can also be useful if we run our code in non-sequential order -- for example if we are experimenting with our code in interactive sessions or Jupyter Notebook environments. \n", "\n", "The example below shows how we can use a `RandomState` object to create the same results that we obtained via `np.random.rand` in the previous code snippet:" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.69646919, 0.28613933, 0.22685145])" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rng1 = np.random.RandomState(seed=123)\n", "rng1.rand(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Reshaping Arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In practice, we often run into situations where existing arrays do not have the *right* shape to perform certain computations. As you might remember from the beginning of this lecture, the size of NumPy arrays is fixed. Fortunately, this does not mean that we have to create new arrays and copy values from the old array to the new one if we want arrays of different shapes -- the size is fixed, but the shape is not. NumPy provides a `reshape` methods that allow us to obtain a view of an array with a different shape. \n", "\n", "For example, we can reshape a one-dimensional array into a two-dimensional one using `reshape` as follows:" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary1d = np.array([1, 2, 3, 4, 5, 6])\n", "ary2d_view = ary1d.reshape(2, 3)\n", "ary2d_view" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.may_share_memory(ary2d_view, ary1d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While we need to specify the desired elements along each axis, we need to make sure that the reshaped array has the same number of elements as the original one. However, we do not need to specify the number elements in each axis; NumPy is smart enough to figure out how many elements to put along an axis if only one axis is unspecified (by using the placeholder `-1`):" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary1d.reshape(2, -1)" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4],\n", " [5, 6]])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary1d.reshape(-1, 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can, of course, also use `reshape` to flatten an array:" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3, 4, 5, 6])" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[[1, 2, 3],\n", " [4, 5, 6]]])\n", "\n", "ary.reshape(-1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sometimes, we are interested in merging different arrays. Unfortunately, there is no efficient way to do this without creating a new array, since NumPy arrays have a fixed size. While combining arrays should be avoided if possible -- for reasons of computational efficiency -- it is sometimes necessary. To combine two or more array objects, we can use NumPy's `concatenate` function as shown in the following examples:" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3, 1, 2, 3])" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([1, 2, 3])\n", "\n", "# stack along the first axis\n", "np.concatenate((ary, ary)) " ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [1, 2, 3]])" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([[1, 2, 3]])\n", "\n", "# stack along the first axis (here: rows)\n", "np.concatenate((ary, ary), axis=0) " ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3, 1, 2, 3]])" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# stack along the second axis (here: column)\n", "np.concatenate((ary, ary), axis=1) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Comparison Operators and Masks" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the previous section, we already briefly introduced the concept of Boolean masks in NumPy. Boolean masks are `bool`-type arrays (storing `True` and `False` values) that have the same shape as a certain target array. For example, consider the following 4-element array below. Using comparison operators (such as `<`, `>`, `<=`, and `>=`), we can create a Boolean mask of that array which consists of `True` and `False` elements depending on whether a condition is met in the target array (here: `ary`):" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([False, False, True, True])" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([1, 2, 3, 4])\n", "mask = ary > 2\n", "mask" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "One we created such a Boolean mask, we can use it to select certain entries from the target array -- those entries that match the condition upon which the mask was created):" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([3, 4])" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary[mask]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Beyond the selection of elements from an array, Boolean masks can also come in handy when we want to count how many elements in an array meet a certain condition:" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([False, False, True, True])" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mask" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mask.sum()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A related, useful function to assign values to specific elements in an array is the `np.where` function. In the example below, we assign a 1 to all values in the array that are greater than 2 -- and 0, otherwise:" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 0, 1, 1])" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.where(ary > 2, 1, 0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are also so-called bit-wise operators that we can use to specify more complex selection criteria:" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 0, 1, 1])" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([1, 2, 3, 4])\n", "mask = ary > 2\n", "ary[mask] = 1\n", "ary[~mask] = 0\n", "ary" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `~` operator in the example above is one of the logical operators in NumPy:\n", " \n", "- A: `&` or `np.bitwise_and`\n", "- Or: `|` or `np.bitwise_or`\n", "- Xor: `^` or `np.bitwise_xor`\n", "- Not: `~` or `np.bitwise_not`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These logical operators allow us to chain an arbitrary number of conditions to create even more \"complex\" Boolean masks. For example, using the \"Or\" operator, we can select all elements that are greater than 3 or smaller than 2 as follows:" ] }, { "cell_type": "code", "execution_count": 65, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ True, False, False, True])" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ary = np.array([1, 2, 3, 4])\n", "\n", "(ary > 3) | (ary < 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And, for example, to negate the condition, we can use the `~` operator:" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([False, True, True, False])" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "~((ary > 3) | (ary < 2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Linear Algebra with NumPy Arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Intuitively, we can think of one-dimensional NumPy arrays as data structures that represent row vectors:" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3])" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "row_vector = np.array([1, 2, 3])\n", "row_vector" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similarly, we can use two-dimensional arrays to create column vectors:" ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1],\n", " [2],\n", " [3]])" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "column_vector = np.array([[1, 2, 3]]).reshape(-1, 1)\n", "column_vector" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Instead of reshaping a one-dimensional array into a two-dimensional one, we can simply add a new axis as shown below:" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1],\n", " [2],\n", " [3]])" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "row_vector[:, np.newaxis]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that in this context, `np.newaxis` behaves like `None`:" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1],\n", " [2],\n", " [3]])" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "row_vector[:, None]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "All three approaches listed above, using `reshape(-1, 1)`, `np.newaxis`, or `None` yield the same results -- all three approaches create views not copies of the `row_vector` array.\n", "\n", "As we remember from the Linear Algebra appendix, we can think of a column vector as a matrix consisting only of one column. To perform matrix multiplication between matrices, we learned that number of columns of the left matrix must match the number of rows of the matrix to the right. In NumPy, we can perform matrix multiplication via the `matmul` function:" ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [], "source": [ "matrix = np.array([[1, 2, 3], \n", " [4, 5, 6]])" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[14],\n", " [32]])" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.matmul(matrix, column_vector)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](./images/numpy-intro/matmul.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "However, if we are working with matrices and vectors, NumPy can be quite forgiving if the dimensions of matrices and one-dimensional arrays do not match exactly -- thanks to broadcasting. The following example yields the same result as the matrix-column vector multiplication, except that it returns a one-dimensional array instead of a two-dimensional one:" ] }, { "cell_type": "code", "execution_count": 73, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([14, 32])" ] }, "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.matmul(matrix, row_vector)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similarly, we can compute the dot-product between two vectors (here: the vector norm)" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "14" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.matmul(row_vector, row_vector)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy has a special `dot` function that behaves similar to `matmul` on pairs of one- or two-dimensional arrays -- its underlying implementation is different though, and one or the other can be slightly faster on specific machines and versions of [BLAS](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms):" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "14" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.dot(row_vector, row_vector)" ] }, { "cell_type": "code", "execution_count": 76, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([14, 32])" ] }, "execution_count": 76, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.dot(matrix, row_vector)" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[14],\n", " [32]])" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.dot(matrix, column_vector)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similar to the examples above we can use `matmul` or `dot` to multiply two matrices (here: two-dimensional arrays). In this context, NumPy arrays have a handy `transpose` method to transpose matrices if necessary:" ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 4],\n", " [2, 5],\n", " [3, 6]])" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix = np.array([[1, 2, 3], \n", " [4, 5, 6]])\n", "\n", "matrix.transpose()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](./images/numpy-intro/transpose.png)" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[14, 32],\n", " [32, 77]])" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.matmul(matrix, matrix.transpose())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](./images/numpy-intro/matmatmul.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While `transpose` can be annoyingly verbose for implementing linear algebra operations -- think of [PEP8's](https://www.python.org/dev/peps/pep-0008/) *80 character per line* recommendation -- NumPy has a shorthand for that: `T`:" ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1, 4],\n", " [2, 5],\n", " [3, 6]])" ] }, "execution_count": 80, "metadata": {}, "output_type": "execute_result" } ], "source": [ "matrix.T" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While this section demonstrates some of the basic linear algebra operations carried out on NumPy arrays that we use in practice, you can find an additional function in the documentation of NumPy's submodule for linear algebra: [`numpy.linalg`](https://docs.scipy.org/doc/numpy/reference/routines.linalg.html). If you want to perform a particular linear algebra routine that is not implemented in NumPy, it is also worth consulting the [`scipy.linalg` documentation](https://docs.scipy.org/doc/scipy/reference/linalg.html) -- SciPy is a library for scientific computing built on top of NumPy." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "\n", "I want to mention that there is also a special [`matrix`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.matrix.html) type in NumPy. NumPy `matrix` objects are analogous to NumPy arrays but are restricted to two dimensions. Also, matrices define certain operations differently than arrays; for instance, the `*` operator performs matrix multiplication instead of element-wise multiplication. However, NumPy `matrix` is less popular in the science community compared to the more general array data structure. \n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## SciPy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "SciPy is another open-source library from Python's scientific computing stack. SciPy includes submodules for integration, optimization, and many other kinds of computations that are out of the scope of NumPy itself. We will not cover SciPy as a library here, since it can be more considered as an \"add-on\" library on top of NumPy. Rather, we may discuss individual SciPy function in the context of homework exercises if the need arises.\n", "\n", "In any case, I recommend you to take a look at the SciPy documentation to get a brief overview of the different function that exists within this library: [https://docs.scipy.org/doc/scipy/reference/](https://docs.scipy.org/doc/scipy/reference/)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Matplotlib" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lastly, we will briefly cover Matplotlib in this lecture. Matplotlib is a plotting library for Python created by John D. Hunter in 2003. Unfortunately, John D. Hunter became ill and past away in 2012. However, Matplot is still the most mature plotting library, and is being maintained until this day (in fact, version 3.1.1 was just released a few months \n", "ago, in July 2019).\n", "\n", "In general, Matplotlib is a rather \"low-level\" plotting library, which means that it has a lot of room for customization. The advantage of Matplotlib is that it is so customizable; the disadvantage of Matplotlib is that it is so customizable -- some people find it a little bit too verbose due to all the different options.\n", "\n", "In any case, Matplotlib is among the most widely used plotting library and the go-to choice for many data scientists and machine learning researchers and practictioners.\n", "\n", "In my opinion, the best way to work with Matplotlib is to use the Matplotlib gallery on the official website at [https://matplotlib.org/gallery/index.html](https://matplotlib.org/gallery/index.html) often. It contains code examples for creating various different kinds of plots, which are useful as templates for creating your own plots. Also, if you are completely new to Matplotlib, I recommend the tutorials at [https://matplotlib.org/tutorials/index.html](https://matplotlib.org/tutorials/index.html).\n", "\n", "In this section, we will look at a few very simple examples, which should be very intuitive and shouldn't require much explanation." ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The main plotting functions of Matplotlib are contained in the pyplot module, which we imported above. Note that the `%matplotlib inline` command is an \"IPython magic\" command -- we discussed this last lecture. This particular `%matplotlib inline` is specific to Jupyter notebooks (which, in our case, use an IPython kernel) to show the plots \"inline,\" that is, the notebook itself." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting Functions and Lines" ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd3hU55X48e8ZVSRAQr0jAaJIgADLYIwrptsGlzi248QlxVviTX7JbhI72U12nc3G2d2UTTZO4rg7iWuMwRgMAuOGwSCbJokOAnUJCRXUpXl/f2jklbEESFPulPN5nnk0c+feuUcwmjP3vE2MMSillApcNqsDUEopZS1NBEopFeA0ESilVIDTRKCUUgFOE4FSSgW4YKsDGIm4uDiTmZlpdRhKKeVTPvroo9PGmPhzt/tkIsjMzKSwsNDqMJRSyqeIyMnBtmtpSCmlApwmAqWUCnCaCJRSKsBpIlBKqQCniUAppQKcSxKBiDwpIrUiUjTE8yIivxaRoyKyT0TmDHjuHhE54rjd44p4lFJKXTxXXRE8DSw7z/PLgWzH7X7gdwAiEgP8CJgHzAV+JCLjXBSTUkqpi+CScQTGmHdFJPM8u6wCnjV9c17vEJFoEUkGrgEKjDENACJSQF9Ced4VcfkDYwz7K5ooqWymx27o6bUzOjyEqyfHEz8mzOrwlHKrQ9UtnDjdSkNrFw2tnSRFjWJeVgxp40YhIlaH5zc8NaAsFSgb8LjcsW2o7Z8hIvfTdzVBRkaGe6L0ImUNbby4q4zX91Vysr7tM8+LwJyMcVw/I5m7LssgLDjIgiiVcr32rl7W7q3gTztOsb+iadB9UqLCWTkrlb+/diJjw0M8HKH/8VQiGCx1m/Ns/+xGYx4DHgPIz8/329V07HbDs9tL+dmbh+js6WXBpDi+fs0k5k+MJTwkiGCbUNnUzuaSWjaVVPPwuhL+/OFJHrl1JpdmxlgdvlJO2XKghu+8so+G1i6yE0bzbytzuWT8OOJGhxEdEUJpfSs7TzTw3pHT/OHdY7xcWMY/LpnC7ZemE2TTK4SR8lQiKAfSBzxOAyod2685Z/vbHorJ65Q1tPFPL+/lwxMNXD05nv+4ZQap0aM+s9+4yFByU6L45qJsth6q5Z9XF3Hb77dz17wMfnhjjl4dKJ/T2dPLIxsO8tS2UnKSx/LoXXOYlxXzmfLP1KSxTE0ay93zM9lf3sSP15Xw/dX7efXjcv54dz7jIkMt+g18m7hqqUpHG8E6Y8z0QZ67HngAWEFfw/CvjTFzHY3FHwH9vYg+Bi7pbzMYSn5+vvG3uYYOVjdz1x8/pKvHzr/ckMNt+WkXXQNt7ezhFwWHeeL9E1yZHcdjX8pnVKgmA+UbTp/t5N6ndlJU0cy9l2fy0IqpF/1lxhjD6t0VPPjqftLGjeKZ++aSHhPh5oh9l4h8ZIzJ/8x2VyQCEXmevm/2cUANfT2BQgCMMb+Xvk+0/6WvIbgNuM8YU+g49svA9x0v9RNjzFMXOp+/JYKSyma++MSHhAQJz3/tMibEjx7R67xUWMaDf91H/vgYnrg3nzFaO1VerrGtizse20FpfSu/vmM2S3KTRvQ6u0ob+OozhYQE2Xj6vkuZnhrl4kj9g1sTgaf5UyIoqmjii098yKiQIJ7/2mVkxkU69Xqv763kWy/uITdlLH/66jxNBsprne3s4a7HP+RAZTNP3JvPldmfmR15WI7UtHDPkztp6+7ltb9f4PTfkj8aKhHoyGIL1TR3cO9TO4kMDebF++e75I17Y14Kv//iJRRVNvOPL+3Fbve9RK/8X0d3L195ehdFFU389q45TicBgOzEMTx//2UAfPXZQpo7up1+zUChicAi3b12vv7nj2nr6uWZL19KRqzr6pqLchL5/oppbCqp4dG3j7rsdZVylZ+8cYAPTzTwi8/nsTgn0WWvOz42kt/ddQmlp1t54C+76em1u+y1/ZkmAov8dP1BCk+e4We3zmRSwhiXv/6XF2SyalYKPy84zNZDtS5/faVGasP+Kp7bcZKvXZnFqlmDDhtyyvyJsfz4pum8e7iO/1h/0OWv7480EVhg3b5Kntx2gnsvz+TGvBS3nENEeOSWmUxNGss3n99NWcNnB6Up5WllDW1896/7yEuP5jtLp7rtPHfOzeCe+eN5ctsJ3jtS57bz+AtNBB5W09zBQ3/dz5yMaL6/YppbzzUqNIg/fPESeu2G76/ejy92DFD+o7vXzjde2A0GfnPHbEKD3fvx89CKaUyIj+R7r+yjRdsLzksTgYf969piunrt/OLzs9z+hwCQERvBd5dN5b0jp1m9u8Lt51NqKH987zi7TzXy01tnuLRNbCjhIUH89215VDd38B/rD7j9fL5ME4EHFZTUsKGomm9cl+3Rrm1fumw8czKieXhdCafPdnrsvEr1Kz/Txq+3HGFpbiI3zHRPOXQwczLG8bUrJ/D8zjLePawloqFoIvCQs509/HBNEVMSx3D/VRM8em6bTfjZrTNp6+zl4ddLPHpupQD+7fUSBOGHN+Z6/NzfWjyZifGRPPTqftq7ej1+fl+gicBD/nvjIaqbO/jprTMICfL8P3t24hi+fu0k1u6t5B39ZqQ8aMuBGgpKavjmouxB585yt/CQIH56y0wqGtt5/L3jHj+/L9BE4AFHalp4dnspd83LYE6Gdevu/N01ExkfG8FP1x+gVweaKQ9o7+rlR2uLyU4YzZcXZFkWx9ysGJblJvG7d45R29xhWRzeShOBB/zXxkNEhAbz7cVTLI0jNNjGd5ZO4WB1C69+XG5pLCowPLntBOVn2nl41XSPdI44nweXT6W7187PNx22NA5vpInAzT46eYZNJTX8zVUTiPGCKXKvn5FMXloUvyg4TEe31kuV+zS1d/OHd46xaFoC8yfGWh0OmXGR3DM/k5c+KqOkstnqcLyKJgI3Msbwsw0HiRsdxleutO6yeCAR4aEV06hq6uCpbaVWh6P82B/fPU5zR4/lV8ID/cPCbKJGhfCT9SU6rmYATQRutPVQLTtLG/jmdZOICPXUGkAXdtmEWBZOTeDRt49yprXL6nCUHzp9tpMnt53gxrwUclLGWh3OJ6IiQviHhdlsO1rPjuPnXfYkoGgicBO73fCfbx4iMzaCO+Z63xrLDy6fytnOHh7TXhTKDR7deozOHjvfWpRtdSifcde8DOJGh/Gbt45YHYrX0ETgJptKajhY3cK3Fk+2pLvohUxOHMOKGck8t/0kTe06/F65TmVjO3/acZLPzUkb8SJL7hQeEsTfXj2BD47VU1iqVwXgokQgIstE5JCIHBWRBwd5/pcissdxOywijQOe6x3w3FpXxGM1Ywy/e+cYGTERXD8j2epwhvT310zkbGcPz20vtToU5Ucee/c4BsM3vPBqoN8X5mUQExnKr9/SadrBBYlARIKA3wLLgRzgThHJGbiPMeZbxphZxphZwG+AVwc83d7/nDFmpbPxeIPtx+rZW9bI31w9gWAvvBrol5sSxbVT4nlyWyltXT1Wh6P8QENrFy/sOsVNs1ItGTx2sSJCg/nqlVm8e7iOPWWNFz7Az7niU2oucNQYc9wY0wW8AKw6z/53As+74Lxe69G3jxE/Joxb56RZHcoFPbBwUt8f784yq0NRfuC57Sfp6LZ7fBqVkbh7fiZRo0L4X20rcEkiSAUGfoqUO7Z9hoiMB7KAtwZsDheRQhHZISI3DXUSEbnfsV9hXZ33TpGwr7yR94+e5itXZBEeEmR1OBd0yfgY5mXF8Ni7x+nq0dWc1Mi1d/XyzPZSFk1LIDvR9YstudrosGC+vCCLzQdqOVTdYnU4lnJFIpBBtg3VQfcO4BVjzMCRTBmOxZS/APxKRCYOdqAx5jFjTL4xJj8+3vn1Td3ld28fY0x4MHfN876eQkP5+rWTqG7uYPVuHW2sRu6Vj8poaO3i/qsG/RP2SnfPH09YsI2ntp2wOhRLuSIRlAPpAx6nAZVD7HsH55SFjDGVjp/HgbeB2S6IyRKlp1t5s7iau+ePZ0x4iNXhXLQrs+OYljyWp7aV6iAbNSI9vXb++N4JZmdEc2mmdfNpDde4yFBumZPG6t0VNATwmBpXJIJdQLaIZIlIKH0f9p/p/SMiU4BxwPYB28aJSJjjfhywAPDZeZKf3X6SIBHumZ9pdSjDIiLcd3kmB6tbdJCNGpE3i6s51dDG31w1EZHBigTe68sLMunssfP8zlNWh2IZpxOBMaYHeADYCBwAXjLGFIvIwyIysBfQncAL5tNfOacBhSKyF9gKPGKM8clE0NrZw8uFZSyfkUzC2HCrwxm2lbNSGBcRwjMflFodivJBz3xQyvjYCBbnJFodyrBlJ47hyuw4nt1eGrDtZC6Z98AYsx5Yf862H57z+F8HOe4DYIYrYrDa6t0VtHT2cO/l460OZUTCQ4K4Y24Gf3jnGOVn2kgb5/6lBJV/OFDVzK7SM/xgxTSCbL51NdDvywuyuO/pXWwoqmLVrEH7uvg17+3k7kOMMTy7vZTpqWMtXW/AWV+8rC+JPbfjpMWRKF/y3I6ThAXbuC3f+7tLD+XqyfFMiIvkifdPBGQ7mSYCF9h+vJ7DNWe5e36mz9VHB0qNHsXS3CRe3FWmS/qpi9Lc0c1ruytYmZdCdIT106yPlM0m3Lcgk33lTewOwAFmmghc4JkPShkXEcLKPM8tyu0u91yeSWNbN2v2VFgdivIBr35UTltXL3f7WAeJwdw0O5WI0CBeCMBGY00ETqpsbKegpIbbL83wiQFkFzIvK4YpiWP4SwD+MajhMcbw3I6T5KVHMyMtyupwnDYmvO/L3Ot7q2juCKyJGDUROOnlwnLsBp8aQHY+IsIdc9PZV95EcWWT1eEoL7b9WD3H6lq5+zLf7CAxmDvnZtDe3cuaPUMNhfJPmgicYLcbXios44pJcaTH+E8vm5tnpxIabOPFXTr/kBran3eeIjoihOtneu8Mu8M1My2KnOSx/OXDUwHVaKyJwAnbjp2morGd2y9Nv/DOPiQ6IpTl05NYvbtC1zVWgzrT2kVBcQ03z071i5JoPxHhznkZHKhqZl954FwRayJwwgu7yoiOCGFJru8NormQ2y9Np6Wjhw1FVVaHorzQmj0VdPXaue0S//oSBLBqVgqjQoICaqSxJoIRahjwjSgs2H++EfW7LCuW8bERPK/TU6tBvFRYzozUKK9aj9hVxjoajdfuraQlQBqNNRGM0Ordfd+I/K0s1M9mE26/NJ2dJxo4XnfW6nCUFymqaKKkqpnP+/AAsgu5Y246bV29rNsXGFfEmghGwBjDS7vKyEuPZmqS/30j6ve5OWkE2UQbjdWnvFxYRmiwjZV5/jsVw6z0aCbER/Lqx4ExNbsmghHYW97EoZoWbs/3z6uBfgljw7l2Sjyv7amg1x44PSjU0Dq6e3ltTyXLcpOIivCdqdaHS0S4dU4au0rPcLK+1epw3E4TwQis/ricsGAbN+T5T7e5odw8O42a5k4+OHba6lCUFygoqaGpvZvP+/mXIOjrRi0Cr37s/6PsNREMU3evndf3VbEoJ5GxPrT4zEhdNy2BMeHBAfHHoC7slY/KSY0exeUTY60Oxe1SHL/nq7vLsfv5FbEmgmF651AdDa1d3DLbf+ujA4WHBHHDzGTeLKqmtbPH6nCUhepaOnnvSB03zU7B5qPTTQ/XrXPSKGtop/DkGatDcSuXJAIRWSYih0TkqIg8OMjz94pInYjscdy+OuC5e0TkiON2jyvicafVuyuIjQzlqsneu26yq90yJ4327l7eLKq2OhRloXX7KrEbuCmA5utfNj2JiNAg/vqRfzcaO50IRCQI+C2wHMgB7hSRnEF2fdEYM8txe9xxbAzwI2AeMBf4kYh47YT+Te3dFByo4ca8FEKCAudiKn/8ONJjRrF6t5aHAtlruyvITRlLduIYq0PxmIjQYJZPT+aN/VV+PcreFZ9mc4Gjxpjjxpgu4AVg1UUeuxQoMMY0GGPOAAXAMhfE5BYb9lfR1WPn5gApC/UTEW6enca2Y6epbuqwOhxlgeN1Z9lb3hRw732AWy9J5WxnD5tKaqwOxW1ckQhSgYEdzcsd2851q4jsE5FXRKS/y8HFHusVXt1dwYS4SGb6wZS7w3Xz7FSMgdd0nYKA9NqeSkTgRj9Yc2O4LsuKJWlsOGv9eEZSVySCwVqNzm1ifx3INMbMBDYDzwzj2L4dRe4XkUIRKayrqxtxsCNVfqaNnScaHF3KAqOhbKCsuEhmZ0TzmpaHAo4xhtd2V7BgYhyJY8OtDsfjbDbhhpnJvHO4lsa2LqvDcQtXJIJyYGCn4jTgU6nTGFNvjOl0PPwjcMnFHjvgNR4zxuQbY/Lj4z3fUPv63r6h5jcF4KVxv1V5KRysbuFITYvVoSgP2l3WyKmGtoB+76+clUJ3r/HbDhOuSAS7gGwRyRKRUOAOYO3AHURk4MirlcABx/2NwBIRGedoJF7i2OZ1Xt9byeyMaL9ad2C4VsxMxibweoDMv6L6vLa7grBgG0v9cJbdizUjNYqsuEjW7vXP8pDTicAY0wM8QN8H+AHgJWNMsYg8LCIrHbt9Q0SKRWQv8A3gXsexDcCP6Usmu4CHHdu8ytHas5RUNXPjzMCrjw6UMCacyybEsm5vZUAt2hHIenrtrN9fxaJpiYwJgAGUQxERbsxLYfvxemqb/a/DhEv6QBpj1htjJhtjJhpjfuLY9kNjzFrH/YeMMbnGmDxjzLXGmIMDjn3SGDPJcXvKFfG42rp9fQ1l/rQS00jdmJfC8dOtFFc2Wx2K8oAPTzRw+mwXNwbAdCoXsjIvBWPwyxlJA6cz/AgZY3h9byVzM2MCsqHsXMtykwi2Ca/76SWy+rR1+yqJDA3imikJVodiuUkJo8lJHssaP3zvayK4gIPVLRyraw3IbnODGRcZypXZcazbV+X3868Euu5eOxuKqlmUk+hXy1E6Y+WsFPaWNfrdjKSaCC7g9b2VBNmE5dOTrA7Fa6yclUJFYzu7y/x7/pVAt+3oaRrburkhwNvGBur/Quhv5SFNBOdhjGHdviounxhL7Ogwq8PxGoumJRIWbPukS63yT+v2VTEmPJirJsdZHYrXSI0exeyMaN7QRBA49pU3caqhTctC5xgTHsK1UxJ4Y3+VLljjpzp7etlYXM2SnCS/XJPbGdfPSKakqpnS0/5THtJEcB5v7K8iJEhYmqNloXOtmJlMXUsnH/n59LyB6r3Dp2np6AmIxZeGa/mMvn+TN/b7z1WBJoIhGGNYv7+KKybF+fWSfCO1cGoCYcE21vvRH4P6P2/sryJqVAgLJmpZ6Fyp0aOYlR7tV+99TQRDKKpopvxM+yfZX33a6LBgrp4cz4Yi7T3kbzp7etlcUsPS3ERCg/UjYjDXz0imuLLZb3oP6f/yENYXVRFsE5bkBO6w+gu5fmYyNc2d2nvIz2w7epqWzh79EnQey2f0lYv9pTykiWAQxhg27K9i/sRYoiNCrQ7Hay2cmkBokI039vnnRFyBav3+asaEB2tZ6DzSxkWQ50flIU0EgzhQ1UJpfRsr9BvReY0JD+GqyXFaHvIj3b12CkpqWDxNy0IXcv2MJIoqmjlV32Z1KE7T/+lBbCiqwiZoWegirJiRTFVTB3vLG60ORbnA9mP1NLV3s0wHUF7Q8un+03tIE8E5jDG8sb+KyyboILKLcd20REKCxG8ukQPdhqJqIkODuGqy59f88DXpMRHMTItiY7Hvl0Y1EZzjcM1Zjte1akPZRYoaFcKV2fGs31+tU1P7uF67YVNxNddOTdC5hS7S0twk9pQ1UtXUbnUoTtFEcI4NRVWIENCLcAzXstwkKhrbdWpqH7fzRAP1rV3aNjYM/SW0jT6+cpkmgnO8WVRN/vhxJIzRKacv1qKcRGyCX1wiB7INRVWEh9i4ZoqWhS7WxPjRZCeM5k0ff++7JBGIyDIROSQiR0XkwUGe/7aIlIjIPhHZIiLjBzzXKyJ7HLe15x7rSSfrWzlY3cLSXG0oG46YyFDmZsX47XqugcBuN2wsrubqyfFEhAZbHY5PWTY9qe9q6mznhXf2Uk4nAhEJAn4LLAdygDtFJOec3XYD+caYmcArwH8OeK7dGDPLcVuJhfq/0WoiGL5luUkcqT3LsbqzVoeiRmBPeSM1zZ3aW2gEluYmYTew+UCN1aGMmCuuCOYCR40xx40xXcALwKqBOxhjthpj+jvb7gDSXHBel9tYXENO8tiAXqB+pJY4kqeWh3zTxuJqgm3CwinaNjZcuSljSY8Z5dNXxK5IBKlA2YDH5Y5tQ/kKsGHA43ARKRSRHSJy01AHicj9jv0K6+rqnIt4ELXNHXx86ox+IxqhlOhR5KVFsbHYd78VBSpjDJuKa5g/MVYnWBwBEWFZbhLbjtbT3NFtdTgj4opEIINsG7QfoYh8EcgH/mvA5gxjTD7wBeBXIjJxsGONMY8ZY/KNMfnx8a5vzNpUUoMxWhZyxtLpSez1g650geZI7VlOnG795KpODd+y6Ul09drZerDW6lBGxBWJoBxIH/A4DfjM6s4isgj4AbDSGPNJq4oxptLx8zjwNjDbBTEN28biarLiIpmcONqK0/uF/iS6Sa8KfEp/10cdST9ys9PHET8mzGdLo65IBLuAbBHJEpFQ4A7gU71/RGQ28Af6kkDtgO3jRCTMcT8OWACUuCCmYWlq72b7sXqW5CYiMtgFjroYn3Sl8+FaaSDaWFLN7IxoEsdql+mRstmExTmJvH2ojo7uXqvDGTanE4Expgd4ANgIHABeMsYUi8jDItLfC+i/gNHAy+d0E50GFIrIXmAr8IgxxuOJ4K2DNfTYjZaFXGBpbhIfnqinobXL6lDURSg/00ZRRbO+911gSU4ibV29fHDstNWhDJtLOgwbY9YD68/Z9sMB9xcNcdwHwAxXxOCMTcU1JIwJY1ZatNWh+LyluUn879ajvHWwls9d4pWdw9QA/WU8TQTOu3xiHGPCgtlUXMPCqb5VZgv4kcUd3b28c7iOJbmJ2GxaFnLW9NSxJEeFs8lHa6WBZmNxNZMTR5MVF2l1KD4vNNjGNVMT2Hyghl4fm5Y94BPBB8dO09bVy2JdoN4lRPpqpe8eqaO9y/dqpYGkobWLXaUNLNH3vsssyUnk9Nkudp/yrVX7Aj4RbCquYUxYMPMnxFodit9YkpNER7ed9464fryHcp0tB2qwa5dpl7pmSjyhQTY2lfhWz7mATgS9dsPmAzVcMzVBV2NyoXkTYhgTHkyBj/0xBJqCkhqSo8KZnjrW6lD8xpjwEC6fFMvGYt+alj2gP/12nzrD6bNd2n/axUKCbFznqJX29NqtDkcNor2rl3eP1LE4R7tMu9qSnCRO1rdxuMZ35t0K6ERQUFJDSJDotLtusCQ3iTNt3Xx00rdqpYHi/aOn6ei2s1i/BLncopwExMemZQ/YRGBM37S78yfGMSZc51dxtasmxxMa7Hu10kCxqbiaMeHBzMvStjFXSxgTzuz0aJ8qjQZsIjhae5bS+jYtC7nJ6LBgrpgU53O10kDQazdsOVjLtVO0bcxdFucksb+iyWfm3QrYd0H/N1W9NHafxTmJlJ9p52B1i9WhqAE+OnmGhtYuluhyrG7T/7my2UeuCgI6EeSl6/wq7nTdtL5aqS9dIgeCgpJqQoKEqydr25i7TEoYzYS4SJ8pjQZkIqhp7mBvWaOWhdwsYUw4s3ysVurvjDFsKqnpmw5B28bcanFOIjuO+8YaBQGZCPqXlNOykPstzkn0qVqpvztSe5aT9W363veAxTmJdPca3jnk/QMrAzIRFJTUMD42guwEXXvA3Zb4WK3U3xVo25jHzM4YR2xkqE9cEQdcIjjb2cMHR+tZPE0H0njCxPi+Cc18pVbq7zaV1JCXFqVtYx4QZBOum5bA1kO1dHv5wMqASwTvHq6jq1cH0nhK/yR0vlIr9Wf9bWP63vecxTlJtHT08OHxBqtDOa+ASwQFJTWMiwjhkvHjrA4lYPhSrdSf/V/bmE4y5ylXTIojPMRGQYl3jzJ2SSIQkWUickhEjorIg4M8HyYiLzqe/1BEMgc895Bj+yERWeqKeIbS3WvnrYO1XDs1geCggMuBlpnjQ7VSf7a5pIaMmAhdl9uDRoUGcWV2PAUlNV49sNLpT0MRCQJ+CywHcoA7RSTnnN2+ApwxxkwCfgn8zHFsDn1rHOcCy4BHHa/nFrtKG2hq79Zuox4WZBMWTvWNWqm/au3sYduxep1kzgKLpyVS2dRBcWWz1aEMyRVfi+cCR40xx40xXcALwKpz9lkFPOO4/wpwnfS9G1cBLxhjOo0xJ4Cjjtdzi4KSGkKDbVyZrQNpPG1xTqJP1Er91buH6+jqsbNomn4J8rSFPjCw0hWJIBUoG/C43LFt0H0ci903AbEXeSwAInK/iBSKSGFd3chqzR3ddq6bmkBkmEuWalbDcGV2POEhtk/q1MqzCkpqiI4I4dJMbRvztLjRYVySMc7vE8Fg15nnFsOG2udiju3baMxjxph8Y0x+fPzIvtH/9JYZPHrXnBEdq5wzKjSIKyZ5f63UH/X02nnrUC0Lp2jbmFUW5yRSUtVMRaN3Dqx0xbuiHEgf8DgNqBxqHxEJBqKAhos81qW0PmqdxTkJVDS2U1LlvbVSf7Sr9AyNbd3abdRC3j4JnSsSwS4gW0SyRCSUvsbftefssxa4x3H/c8Bbpu9r4VrgDkevoiwgG9jpgpiUF1o4NdHra6X+qL9t7CqdZM4yE+JHMzE+0mvf+04nAkfN/wFgI3AAeMkYUywiD4vISsduTwCxInIU+DbwoOPYYuAloAR4E/i6MabX2ZiUd4ofE8YcL6+V+htjDAUHqlkwMVbbxiy2OCeJHcfraWr3voGVLikYGmPWG2MmG2MmGmN+4tj2Q2PMWsf9DmPMbcaYScaYucaY4wOO/YnjuCnGmA2uiEd5r8U5iRRXem+t1N8cqmmhrKFdB5F5gcU5ifTYDW8fqrU6lM/QliPlUd5eK/U3BcV9/86LpiVYHImanR5N3Ogwr7wi1kSgPGpi/GgmeHGt1N8UHKhhVno0CTrJnOVsNmHRtATeOdQ3psObaCJQHtc/CZ031kr9SXVTB/vKm7S3kBdZnJNIS2cPO4KM8qYAABcoSURBVI7XWx3Kp2giUB63xItrpf6kwDF4T6dU8R4LJsURERrEJi+bhE4TgfK4WenjiBsdpmsUuFlBSQ2ZsRFM0gWYvEZ4SBBXZcezuaTWqwZWaiJQHhc0oFba2aO9hd2hpaOb7cdO6yRzXmhJbiLVzR3sr2iyOpRPaCJQlliSm8jZzh62H/OuWqm/eOdwHd29RruNeqGFUxMIsgmbir3nilgTgbLE5RP7aqXae8g9NhbXEBsZqgsweaHoiFAuzfSugZWaCJQlwkOCuHpy3yR0drv31Er9QWdPL1sP1rJoWiJBNi0LeaMlOUkcqmnhZH2r1aEAmgiUhZbkJlLb0sne8karQ/ErO443cLazhyW52lvIW/V36fWWqwJNBMoy107pq5V6yx+Dv9hUXE1EaBALJsVZHYoaQnpMBFOTxnhNO4EmAmWZ6IhQ5mXFaDdSF7LbDQUlNVw9OZ7wELet+qpcYEluEoUnGzh9ttPqUDQRKGstzknkaO1ZjtedtToUv7C3vJHalk4tC/mApbmJ2A1s8YJV+zQRKEstye3r3rjRSy6Rfd2mkhqCbMLCKZoIvF1O8ljSxo3yive+JgJlqdToUcxIjWJjsXcNufdVm4qruWxCDFERIVaHoi5ARFiam8T7R05ztrPH0lg0ESjLLc1NZE9ZI9VNHVaH4tOO1Z3lWF0rS3QQmc9YkpNIV6/d8nm3nEoEIhIjIgUicsTx8zOjV0RklohsF5FiEdknIrcPeO5pETkhInsct1nOxKN801JHeajAyybi8jX9V1U626jvyM+MITYy1PLykLNXBA8CW4wx2cAWx+NztQF3G2NygWXAr0QkesDz3zHGzHLc9jgZj/JBkxL61iiw+o/B120sqiYvLYqU6FFWh6IuUt+8W4lsPVhr6bxbziaCVcAzjvvPADedu4Mx5rAx5ojjfiVQC+gq2uoT/bXSHcfraWrTNQpGoqKxnb3lTSydrmUhX7N0uvXzbjmbCBKNMVUAjp/nXQ9PROYCocCxAZt/4igZ/VJEws5z7P0iUigihXV1dU6GrbzN0twkeuyGLQf1qmAkNjnKQstyNRH4mssnxhEZGmTpFfEFE4GIbBaRokFuq4ZzIhFJBp4D7jPG9K/T9hAwFbgUiAG+N9TxxpjHjDH5xpj8+Hi9oPA3M1OjSBobzptF2k4wEm8WVTM5cTQT4nXtAV8THhLENVMSKCipodeiebcumAiMMYuMMdMHua0Bahwf8P0f9IM2fYvIWOAN4J+NMTsGvHaV6dMJPAXMdcUvpXyPzSYszU3k3SN1tHfpGgXDUX+2k12lDXo14MOWTk/i9NlOPjp5xpLzO1saWgvc47h/D7Dm3B1EJBRYDTxrjHn5nOf6k4jQ175Q5GQ8yoctzU2io9vOO4d1Ccvh2HygBrtB2wd82MKpCYQG29hQVGXJ+Z1NBI8Ai0XkCLDY8RgRyReRxx37fB64Crh3kG6ifxaR/cB+IA74dyfjUT5sblYM4yJC2KDloWF5s6ia9JhR5CSPtToUNUKjw4K5KjuejUXVlixhGezMwcaYeuC6QbYXAl913P8T8Kchjl/ozPmVfwkOsrE0N4l1+6ro7OklLFgnTbuQ5o5uth2t5+7543VJSh+3fHoSmw/UsLe8iVnp0Rc+wIV0ZLHyKsumJ3G2s4f3j5y2OhSfsPVgLV29dpZpWcjnLZqWSLBN2LDf8+UhTQTKq1w+MY6x4cGs36/loYuxfn8ViWPDmJOhS1L6uqiIEC6fFMcGC8pDmgiUVwkNtrEoJ5GCkmq6euwXPiCAtXb28PahOpZPT8amS1L6heXTkzjV0EZJVbNHz6uJQHmdFdOTae7oYftx60Za+oK3DtbS2WNnuZaF/MaSnERsgsfH02giUF7niuw4RocFW1Ir9SXr91cRPyaM/MwYq0NRLhI7Oox5WbEe7zmniUB5nfCQIBZOTWBjcTU9vVoeGkxbVw9bD9WyfHoSQVoW8isrZiRxtPYsh2taPHZOTQTKK62YkcSZtm52HG+wOhSvtPVgHR3ddlbMSLY6FOViS6cnYRNYt89zV8SaCJRXunpyAhGhQbyh5aFBrd9fRdzoMC7VspDfSRgTzrysWNbtq/RY7yFNBMorjQoNYtG0RDYUVdGt5aFPae/q5a2DtSybnqhlIT91Q14yx+taOVjtmfKQJgLltW6YmUxjWzfbjurgsoG2HqqlvbtXy0J+bFluX9vPun2VHjmfJgLlta6eEs+YsGCP1kp9wbp9lcQ5epco/xQ7OozLJ8aybl+VR8pDmgiU1woLDmJxbiIbi6stXcbPm7R0dLPlQC03zEzWspCfu35GMifr2yiudP/gMk0EyqvdmJdCS0cP7x7W8hBAQUkNnT12bsxLsToU5WZLc5MItgmve6A8pIlAebUrJsURHRHisVqpt3t9byWp0aOYk+HZ2SmV542LDGXBpDje8EB5SBOB8mohQTaW5SaxuaQm4FcuO9PaxXtHTnNjXopOOR0gbpiZTPmZdnaXNbr1PE4lAhGJEZECETni+DnoFIgi0jtgUZq1A7ZniciHjuNfdKxmptSn3JiXQmtXL1sPBfbKZeuLquixG27M095CgWLp9CTCgm2s2V3h1vM4e0XwILDFGJMNbHE8Hky7MWaW47ZywPafAb90HH8G+IqT8Sg/NC8rhrjRYazZ494/Bm/3+t5KJsZH6kpkAWRseAiLpiWybp97x9M4mwhWAc847j9D37rDF8WxTvFC4JWRHK8CR3CQjZV5KWw9WEdjW5fV4ViiuqmDD080sDIvVctCAWbVrBTqW7t4343jaZxNBInGmCoAx8+EIfYLF5FCEdkhIv0f9rFAozGmx/G4HEh1Mh7lp26Zk0pXrz1gF6zpm24ALQsFoGumJBA1KsSt5aELrlksIpuBwSY8/8EwzpNhjKkUkQnAW44F6wfrHDtk07iI3A/cD5CRkTGMUyt/kJsylkkJo3ltdwVfmBd4//+vflxBXloUE+JHWx2K8rDQYBsrZiSzZk8FbV09RIQ6tdT8oC54RWCMWWSMmT7IbQ1QIyLJAI6fg7bmGWMqHT+PA28Ds4HTQLSI9P9WacCQfQSNMY8ZY/KNMfnx8fHD+BWVPxARbp6dys7SBsoa2qwOx6MOVDVTUtXMLXPSrA5FWeSmWSm0dfVSUFLjltd3tjS0FrjHcf8eYM25O4jIOBEJc9yPAxYAJaavY+xW4HPnO16pfqtm9Q2iCrRG49W7Kwi2iQ4iC2CXZsaQEhXOa24qDzmbCB4BFovIEWCx4zEiki8ijzv2mQYUishe+j74HzHGlDie+x7wbRE5Sl+bwRNOxqP8WNq4COZmxbB6d4XHF/e2Sk+vndW7K7h2agIxkdq7OlDZbMLKWam8e+Q09Wc7Xf76ThWbjDH1wHWDbC8Evuq4/wEwY4jjjwNznYlBBZabZ6fy0Kv7KapoZkZalNXhuN22Y/XUtXRy6xztRxHobp6dSkVjO21dvbh6ukEdWax8yooZyYQG2/jrx+VWh+IRr35cTtSoEK6dOlSHPBUopiSN4Td3ziY9JsLlr62JQPmUqFEhLMlJ5LU9FX4/I2lLRzcbi6u5MS+ZsOAgq8NRfkwTgfI5t1+aTmNbt9t6UHiLDUXVdHTbtbeQcjtNBMrnLJgYR2r0KF7cVWZ1KG710q4yJsRFMjtdZxpV7qWJQPkcm0343CVpvH/0NOVn/HNMweGaFgpPnuGOuek6pYRyO00Eyifdlt9XLnnlI/9sNH5hZxkhQcKtWhZSHqCJQPmktHERXDEpjpcLy7Hb/WtMQUd3L6/uLmdJThKxo8OsDkcFAE0Eymd9Pj+disZ2PjhWb3UoLrWxuJrGtm7umJtudSgqQGgiUD5rcU4i0REhPL/zlNWhuNQLO8tIjxnFgolxVoeiAoQmAuWzwkOCuO2SNDYWV1PT3GF1OC5RerqV7cfruT0/HZtNG4mVZ2giUD7ti5eNp9cY/vKhf1wVPL/rFEE24bZ8LQspz9FEoHza+NhIrpkcz192nqKrx31L+XlCe1cvL+4qY/G0RBLHhlsdjgogmgiUz7t7fiZ1LZ1sLPbt1cte21NBY1s39y3ItDoUFWA0ESifd/XkeDJiInhu+0mrQxkxYwxPbTvBtOSxzM2KsTocFWA0ESifZ7MJX7psPDtLGzhQNdgKqN5v+7F6Dtec5b4FmTqSWHmcJgLlF27LTyMs2Maz20utDmVEntxWSmxkKCt1FTJlAacSgYjEiEiBiBxx/Bw3yD7XisieAbcOEbnJ8dzTInJiwHOznIlHBa7oiFBumZPGXz+uoLbFt7qSnqpvY8vBGr4wL4PwEJ1uWnmes1cEDwJbjDHZwBbH408xxmw1xswyxswCFgJtwKYBu3yn/3ljzB4n41EB7G+umkBPr52ntpVaHcqwPP1BKUEifPGy8VaHogKUs4lgFfCM4/4zwE0X2P9zwAZjjH9OGakslRkXyfLpyfxpx0laOrqtDueiNLR28cKuU9yYl6JdRpVlnE0EicaYKgDHzwutp3cH8Pw5234iIvtE5JciMuQMWyJyv4gUikhhXV2dc1Erv/W3V0+kpaPHZwaYPbXtBG1dvfz9NROtDkUFsAsmAhHZLCJFg9xWDedEIpJM3yL2GwdsfgiYClwKxADfG+p4Y8xjxph8Y0x+fHz8cE6tAsiMtCgWTIrlifdPeP1Sls0d3Tz9QSnLpyeRnTjG6nBUALtgIjDGLDLGTB/ktgaocXzA93/Q157npT4PrDbGfHLNboypMn06gaeAuc79OkrB3109idqWTlZ/XGF1KOf13PaTtHT08PVrJ1kdigpwzpaG1gL3OO7fA6w5z753ck5ZaEASEfraF4qcjEcpFkyKZUZqFI++fYzuXu+cdqKtq4fH3zvOtVPimZ4aZXU4KsA5mwgeARaLyBFgseMxIpIvIo/37yQimUA68M45x/9ZRPYD+4E44N+djEcpRIRvLc7mVEOb165r/JcPT3GmrZsHFmZbHYpSBDtzsDGmHrhukO2FwFcHPC4FUgfZb6Ez51dqKNdOSeDSzHH8essRbp2TxqhQ7+mf39LRze/fOcblE2O5ZPxnht4o5XE6slj5JRHhu8umUtvSydMflFodzqf84Z3jnD7bxfeWTbU6FKUATQTKj12aGcO1U+L5/TvHaGr3jnEFVU3tPP7+cVbmpZCXHm11OEoBmgiUn/vO0qk0tXfzh3eOWR0KAD/fdBi7Hb6zdIrVoSj1CU0Eyq/lpIzlplkpPP7+CUpPt1oaS0llM3/9uJx7F2SSHhNhaSxKDaSJQPm9h1ZMIzTIxr+sKcIYY0kMxhj+/Y0SokaF8PVrdNyA8i6aCJTfSxwbzj8tmcx7R06zbl+VJTG8/FE5Hxyr5x8XTyYqIsSSGJQaiiYCFRC+ND+TGalRPLyuxOMNxzXNHfx4XQlzs2K4a57OMKq8jyYCFRCCbMJ/3DyD+rOd/PfGQx47rzGGH6wuoqvHzs9unYnNpquPKe+jiUAFjBlpUdx7eRbP7TjJlgM1Hjnn6/uq2Hyghn9aMoWsuEiPnFOp4dJEoALKd5dNISd5LN9+aS/lZ9y7LMap+jZ+uKaIvPRovnxFllvPpZQzNBGogBIeEsSjd83Bbjc88JfddPW4Z1K61s4evvZsIcbA/9w+iyAtCSkvpolABZzMuEj+83Mz2VPWyE83HHD569vthm+/tIcjtS387xdmk6klIeXlNBGogLR8RjL3LcjkqW2lPPr2UZe+9q/fOsLG4hq+v2IaV2brIkrK+zk1+6hSvuyfr8+hobWL/3zzECE2G1+7aoJTr2eM4bdbj/KrzUe4ZU4qX9F2AeUjNBGogBVkE35+Wx49dsNP1h/AZpMRf3jb7YZ/f+MAT247wS2zU/nZrTPpW29JKe+niUAFtOAgG7+6fRZ2u+HH60ooqmji31blMjb84kf/tnR08y+vFfHankq+vCCLf75+mo4XUD7FqTYCEblNRIpFxC4i+efZb5mIHBKRoyLy4IDtWSLyoYgcEZEXRSTUmXiUGomQIBu/uXM231o0mbV7K1n+q/fYfqz+gscZY1izp4KFP3+HNXsr+c7SKfzLDZoElO8RZybhEpFpgB34A/BPjpXJzt0nCDhM31KW5cAu4E5jTImIvAS8aox5QUR+D+w1xvzuQufNz883hYWfOZVSTtt96gzfenEPpfVt5KVHc9sladyYl0LUqP+7QjhV38Y7R+pYu6eCXaVnmJkWxY9XTdf1BZTXE5GPjDGf+dLuVCIY8OJvM3QimA/8qzFmqePxQ46nHgHqgCRjTM+5+52PJgLlTq2dPTy/8xQvF5ZzqKYFERgdGkxkWDAiUNXUAUDauFH87dUTuXNuho4TUD5hqETgiTaCVGDgCuLlwDwgFmg0xvQM2P6ZdY37icj9wP0AGRkZ7olUKSAyLJivXjmBr1yRRVFFM5sP1NDc0U1rZw9dPXby0qO5enI8WXGR2iCs/MIFE4GIbAaSBnnqB8aYNRdxjsH+Usx5tg/KGPMY8Bj0XRFcxHmVcoqIMCMtihlpUVaHopRbXTARGGMWOXmOciB9wOM0oBI4DUSLSLDjqqB/u1JKKQ/yxMjiXUC2o4dQKHAHsNb0NU5sBT7n2O8e4GKuMJRSSrmQs91HbxaRcmA+8IaIbHRsTxGR9QCOb/sPABuBA8BLxphix0t8D/i2iBylr83gCWfiUUopNXwu6TXkadprSCmlhm+oXkM66ZxSSgU4TQRKKRXgNBEopVSA00SglFIBzicbi0WkDjg5wsPj6BvDEEj0dw4M+jv7P2d/3/HGmM+sluSTicAZIlI4WKu5P9PfOTDo7+z/3PX7amlIKaUCnCYCpZQKcIGYCB6zOgAL6O8cGPR39n9u+X0Dro1AKaXUpwXiFYFSSqkBNBEopVSAC6hEICLLROSQiBwVkQetjsedRCRdRLaKyAERKRaRb1odk6eISJCI7BaRdVbH4gkiEi0ir4jIQcf/93yrY3I3EfmW431dJCLPi0i41TG5mog8KSK1IlI0YFuMiBSIyBHHz3GuOFfAJAIRCQJ+CywHcoA7RSTH2qjcqgf4R2PMNOAy4Ot+/vsO9E36pjwPFP8DvGmMmQrk4ee/u4ikAt8A8o0x04Eg+tY58TdPA8vO2fYgsMUYkw1scTx2WsAkAmAucNQYc9wY0wW8AKyyOCa3McZUGWM+dtxvoe/DYcg1of2FiKQB1wOPWx2LJ4jIWOAqHGt5GGO6jDGN1kblEcHAKBEJBiLww9UNjTHvAg3nbF4FPOO4/wxwkyvOFUiJIBUoG/C4nAD4YAQQkUxgNvChtZF4xK+A7wJ2qwPxkAlAHfCUoxz2uIhEWh2UOxljKoD/Bk4BVUCTMWaTtVF5TKIxpgr6vuwBCa540UBKBDLINr/vOysio4G/Av/PGNNsdTzuJCI3ALXGmI+sjsWDgoE5wO+MMbOBVlxULvBWjrr4KiALSAEiReSL1kbl2wIpEZQD6QMep+GHl5MDiUgIfUngz8aYV62OxwMWACtFpJS+0t9CEfmTtSG5XTlQbozpv9p7hb7E4M8WASeMMXXGmG7gVeByi2PylBoRSQZw/Kx1xYsGUiLYBWSLSJaIhNLXuLTW4pjcRkSEvrrxAWPML6yOxxOMMQ8ZY9KMMZn0/f++ZYzx62+KxphqoExEpjg2XQeUWBiSJ5wCLhORCMf7/Dr8vIF8gLXAPY779wBrXPGiwa54EV9gjOkRkQeAjfT1MnjSGFNscVjutAD4ErBfRPY4tn3fGLPewpiUe/wD8GfHF5zjwH0Wx+NWxpgPReQV4GP6esftxg+nmhCR54FrgDgRKQd+BDwCvCQiX6EvId7mknPpFBNKKRXYAqk0pJRSahCaCJRSKsBpIlBKqQCniUAppQKcJgKllApwmgiUUirAaSJQSqkA9/8B6DWfSZYNk14AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.linspace(0, 10, 100)\n", "plt.plot(x, np.sin(x))\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Add axis ranges and labels:" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEGCAYAAACKB4k+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXCc933f8fcXi4u4FgABisTBQyQkmQQpUqRIx1Icx0cjxYmUadyO1Ekap06UdCKfcVq5STSOmjQTJxN3kmpaq3YaT2NHVpRLTdkoh+U4smyJIEWRAA+JNw4e4IEFSBD3t3/sAlpDALEg98Hz7O7nNYMhdvfB4rsEuR/8ft/n93vM3REREQEoCrsAERGJDoWCiIjMUCiIiMgMhYKIiMxQKIiIyIzisAtYrIaGBl+7du1Nfe3A8DjdV4bZ0FjFstJYdgsTkbw0/b6xvrGKihx+39i7d+9Fd29c6LicC4W1a9fS0dFxU1975doY23/z7/nY+9v4zIfuyHJlIpKPPv2N/fzTm/3s+dUPEiuysMu5aWZ2OpPjCmr6qK6ylO1r6vjHw+fDLkVEcsDUlPNPb/bzQ3c05nQgLEZBhQLA+++6ja6+Qc4lRsIuRUQi7kBvgsvXxnjfnQvOuuSNgguFD75rBQDfPHIh5EpEJOpeOnIBM3hvm0Ihb21YUUVr/TJNIYnIgr519ALbWmupqywNu5QlU3ChYGa8/84VvHL8EqMTk2GXIyIRdfHqKAd6E/zwnSvCLmVJFVwoANzf1sj18UlePzMQdikiElHffrMfd3ifQiH/7bq9nliR8fJbF8MuRUQi6qWj/TRUlbGpqSbsUpZUQYZCTXkJW1trefmYQkFE3mlyyvn2m/28785GigrkVNRpBRkKAPdtaOBAzwCJ4fGwSxGRiNnffYXE9fGC6ydAAYfCD7Y1MOXw3ROXwi5FRCLmpSP9xIqM+9sawi5lyQUaCmb2gJkdNbNjZvbEHI9/0cz2pz7eNLMl6/xuba2lsjTGy8f6l+pbikiO+PZb/dyzupb4spKwS1lyge19ZGYx4GngQ0APsMfMXnD3Q9PHuPun047/OLAtqHpmK4kV8e7bl/OdYxopiMjbEsPjHOxN8MkPtIVdSiiCHCnsBI65+wl3HwOeBR6+wfGPAn8aYD3vcN+GBk5evEbPleGl/LYiEmHfO3kJd3jP+sKbOoJgQ6EZ6E673ZO67x3MbA2wDvjmPI8/ZmYdZtbR35+96Z4fTM0XfkdnIYlIyivHLrKsJMbW1tqwSwlFkKEw13lcPs+xjwDPu/ucS4zd/Rl33+HuOxobs7cHyYYVVdxWU8Y/a72CiKS8cvwS966rp7S4MM/DCfJV9wCtabdbgL55jn2EJZ46guSWF/dtaOCV45eYmpovr0SkUFwYHOGtC1e5b/3ysEsJTZChsAdoM7N1ZlZK8o3/hdkHmdmdQB3w3QBrmdf9Gxq4fG2MQ2cHw/j2IhIhrxxPnnhy34bC7CdAgKHg7hPA48CLwGHgOXfvMrOnzOyhtEMfBZ5191B+Vb9/g/oKIpL0yvGLxJeV8K5VhbW1RbpAL8fp7ruB3bPue3LW7c8HWcNCVtSUc8dtVbx87CK/8EPrwyxFRELk7nzn2CV+4PblBXOVtbkUZidllvs3NPLaycuMjGsrbZFC1X35Or0D13nPhsLtJ4BCAYD725YzOjHF3tNXwi5FRELynePJKeRCXZ8wTaEA7Fq3nOIi066pIgXsleOXWFFdxvrGyrBLCZVCAagsK+ae1XW6voJIgXJ3vnv8IvdtaMCscPsJoFCYcd+GBjr7Ely5NhZ2KSKyxI6eH+Li1TF+oIDXJ0xTKKTc39aA+9vnKYtI4XgltTHmexQKCoVpd7fEqSor5pXjmkISKTSvHL/ImuUVtNRVhF1K6BQKKcWxIravqePVk5fDLkVEltDE5BSvnrhc8GcdTVMopNl1ez3HLlzl4tXRsEsRkSVysDfB0OiEpo5SFAppdq1L/qPYo9GCSMGY7iOqyZykUEizuTnOspKYppBECsgrxy9y18pqGqrKwi4lEhQKaUqLi7hnTa1CQaRAjIxP0nHqivoJaRQKs+xat5wj5wZJDI+HXYqIBGzfmSuMTkypn5BGoTDLrnX1uMNrpzRaEMl3r564jBnsvL0+7FIiQ6Ewy92ttZQWF/HqCS1iE8l3r528zMZVNdSUl4RdSmQoFGYpT12wWyMFkfw2NjHF691XuHetRgnpFApzePe6ejp7EwyNqK8gkq86+xKMjE+xc51CIZ1CYQ67bl/OlEOHrq8gkrdeS51lqJHC91MozGHb6lqKi4xXT2gKSSRf7Tl5mdsbKmms1vqEdAqFOVSUFrOlJc5rJ9VsFslHU1NOx2n1E+YSaCiY2QNmdtTMjpnZE/Mc86/N7JCZdZnZ14OsZzF23b6cAz0Jhscmwi5FRLLszQtDJK6Pq58wh8BCwcxiwNPAg8BG4FEz2zjrmDbgc8B97r4J+FRQ9SzWrnX1TEw5+04PhF2KiGTZdD9BofBOQY4UdgLH3P2Eu48BzwIPzzrm54Gn3f0KgLtfCLCeRdm+po4ig1c1hSSSd147eZmVNeW01C0Lu5TICTIUmoHutNs9qfvS3QHcYWbfMbPvmdkDcz2RmT1mZh1m1tHf3x9Qud+vuryE9ua49kESyTPuzp5Tl9m5rr7gr8c8lyBDYa6/bZ91uxhoA94HPAp82cxq3/FF7s+4+w5339HY2Jj1Queza109+7sHGBmfXLLvKSLBOnN5mPODo9yrqaM5BRkKPUBr2u0WoG+OY/7a3cfd/SRwlGRIRMKudcsZm5hif7f6CiL5YqafoDOP5hRkKOwB2sxsnZmVAo8AL8w65q+AHwYwswaS00knAqxpUe5dW48ZWq8gkkf2nLpMfFkJbSuqwi4lkgILBXefAB4HXgQOA8+5e5eZPWVmD6UOexG4ZGaHgJeAX3H3yHR24xUl3LWyhtdORaYkEblFe04l1ycUFamfMJfiIJ/c3XcDu2fd92Ta5w58JvURSbvW1fPsnjOMTUxRWqy1fiK57MLQCCcvXuPRna0LH1yg9C63gF3r6hkZn6KzLxF2KSJyi/acTO5nppXM81MoLGD7mjoA9mlzPJGct+fUZZaVxGhvjoddSmQpFBawoqac1vpl7FUoiOS8V09e5p41tZTE9NY3H/3NZGD76jo6Tl8h2QIRkVyUuD7OkXODmjpagEIhA9vX1tM/NErPlethlyIiN2nf6Su4a7+jhSgUMrB9dbKv0HFa6xVEctWrJy9TEjO2tdaFXUqkKRQycOfKaqrKitVXEMlhe05dpr05zrLSWNilRJpCIQOxImPb6lo6TikURHLRyPgkB3oGtLVFBhQKGdq+po6j54cYGhkPuxQRWaTO3gTjkz5zirnMT6GQoe1r6nBHm+OJ5KB9Z5Kj/HsUCgtSKGRoa2stRYamkERy0N7TV1hdX0FDVVnYpUSeQiFD1eUl3LmyZuY3DhHJDe7OvjMDmjrKkEJhEbavqeX1MwNMTmkRm0iu6Llynf6hUe5Z/Y7rd8kcFAqLsGNNPVdHJzh6bijsUkQkQ9Oj+22rNVLIhEJhEaaHn3s1hSSSM/advkJFaYy7VlaHXUpOUCgsQkvdMhqry9h7SiubRXLFvjMD3N1SS7E2wcuI/pYWwczYsaZOIwWRHDE8NsGhs4Pcs0b9hEwpFBZp+5o6ui9f58LgSNiliMgCDvQkmJxy7lE/IWMKhUWa6StoHySRyFOTefEUCou0qSlOWXERHQoFkcjbd3qA2xsqqa8sDbuUnBFoKJjZA2Z21MyOmdkTczz+UTPrN7P9qY+fC7KebCgtLuLullqNFEQizt15/cwVjRIWKbBQMLMY8DTwILAReNTMNs5x6DfcfWvq48tB1ZNN96ypo6svwcj4ZNiliMg8Tl8a5tK1Ma1kXqQgRwo7gWPufsLdx4BngYcD/H5LZvuaOsYnnQM9ibBLEZF5vL0Jns48WowgQ6EZ6E673ZO6b7afNLMDZva8mbXO9URm9piZdZhZR39/fxC1LoqazSLRt+/MFarKimlboUVrixFkKNgc983eNOj/AGvdfQvwD8BX53oid3/G3Xe4+47GxsYsl7l49ZWl3N5QyV5dnlMksvadHmBray2xorneimQ+QYZCD5D+m38L0Jd+gLtfcvfR1M3/CWwPsJ6s2ra6jtfPDOCuzfFEoubq6ARHzg3q+gk3IchQ2AO0mdk6MysFHgFeSD/AzFal3XwIOBxgPVm1dXUtl66N0XPletiliMgsB7oHmHK0M+pNKA7qid19wsweB14EYsAfuXuXmT0FdLj7C8AnzOwhYAK4DHw0qHqybVtr8h/b690DtNZXhFyNiKSbWbTWqpHCYgUWCgDuvhvYPeu+J9M+/xzwuSBrCMqdK6spKy5i/5kBHrq7KexyRCTN3tNXaFtRRbyiJOxSco5WNN+kklgRW1ri7O/WGUgiUeLuvN49oP2ObpJC4RZsba2ls2+QsYmpsEsRkZQTF68xMDyu9Qk3SaFwC7a21jE2McXhs4NhlyIiKftS64c0Urg5CoVbsDV1ZsP+7oGQKxGRafvODFBTXsz6xqqwS8lJCoVb0BQvp7G6TKEgEiH7uwfYurqOIi1auykKhVtgZmxtrVUoiETE8NgEb54fYmtLPOxScpZC4RZtba3l5MVrDAyPhV2KSMHr7B1kcsq5u1VN5pulULhF04vYNFoQCd8bqf+HCoWbp1C4RVtaazFTKIhEwf6eAVrqltFQVRZ2KTlLoXCLqsqKuWNFNa+fUSiIhG3/mQGNEm6RQiELtrbW8kaPdkwVCVP/0Ci9A9fZ2qJQuBUKhSzYurqWgeFxTl0aDrsUkYJ1oCc5Wt+qnVFviUIhC7bONJu1D5JIWPZ3DxArMjY11YRdSk5TKGTBHbdVU1EaY7/6CiKh2d89kPq/GOjmz3lPoZAFsSJjc3NcZyCJhMTdeaN7YGbULjdPoZAlW1fXcujsICPjk2GXIlJwTl68xuDIBFtbtZL5VikUsmRbax3jk84h7ZgqsuTe6NGitWxRKGTJttQZD1qvILL03uhOUFEao21Fddil5LxFhYKZFZmZWvtzuK2mnFXxcvUVRELwevcAm5vjxLQz6i1bMBTM7OtmVmNmlcAh4KiZ/UrwpeWe5I6pOi1VZCmNTkxyuG9QTeYsyWSksNHdB4GfAHYDq4GfzuTJzewBMztqZsfM7IkbHPcRM3Mz25FR1RG1tbWW7svXuXR1NOxSRArGkbNDjE1OqZ+QJZmEQomZlZAMhb9293Fgwf0czCwGPA08CGwEHjWzjXMcVw18Anh1MYVH0VbtmCqy5Kb/v2mkkB2ZhMKXgFNAJfBtM1sDZHKKzU7gmLufcPcx4Fng4TmO+8/AF4CRjCqOsM0tcYrs7e17RSR4b3QP0Fhdxqp4edil5IUFQ8Hd/8Ddm939Rz3pNPDDGTx3M9Cddrsndd8MM9sGtLr739zoiczsMTPrMLOO/v7+DL51OCpKi2lbUc2B3kTYpYgUjP09A9zdUouZmszZMO96cDP7KXf/EzP7zDyH/P4Czz3XT2hm2snMioAvAh9dqEh3fwZ4BmDHjh2R3op0S0ucfzxyAXfXP1KRgCWGxznRf42fvKcl7FLyxo1GCpWpP6vn+VhID9CadrsF6Eu7XQ20A98ys1PAu4EXcr3ZvKW1lsvXxui5cj3sUkTy3oHe1KI1bZedNfOOFNz9S6k/f2P2Y2ZWmsFz7wHazGwd0As8AvybtOdPAA1pz/kt4LPu3pFp8VF0d+qC4Qd6ErTWV4RcjUh+m+7fbW7R9hbZksk6hW+Z2dq02/eSfMO/IXefAB4HXgQOA8+5e5eZPWVmD910xRF358pqSmNFM7/BiEhw9ncPcHtjJfFlJWGXkjcy2WP2t4G/NbM/INkofhD42Uye3N13k1zbkH7fk/Mc+75MnjPqyopj3LWqmgPdajaLBMnd2d+d4L13NCx8sGRswVBw9xfN7BeBvwcuAtvc/VzgleWwLS1x/vr1PqamnCItuxcJRF9ihItXR7U+IcsymT76deAPgfcCnyfZGP5wwHXltC0ttQyNTnDi4rWwSxHJW9P9BDWZsyuTxWsNwE53/26q+fwjwKeCLSu3Tf8jPai+gkhgDvQkKIkZd63SzqjZlMnitU+6+/W026fd/UPBlpXb1jdWsqwkxhvqK4gE5mDvAHetrKGsOBZ2KXllwZ6CmTUC/5Hk/kUz68jd/f0B1pXTimNFtDfXcKBHIwWRILg7B3oS/PjdTWGXkncymT76GslTStcBv0FyH6QFT0ktdFtaaunqG2R8cirsUkTyzulLwwyNTLClWesTsi2TUFju7l8Bxt39n9z935FcfSw3sKUlzujEFG+dvxp2KSJ5Z/rym1q0ln2ZhMJ46s+zZvbh1CZ22mhkAVtSzWZNIYlk38GeBGXFRdxxm5rM2ZZJKPymmcWBXwY+C3wZ+HSgVeWBtcsrqCkv5o0eNZtFsu1Ab4KNTTWUxHSZ+WzLZPHa9LbWCTLbMlsAM2NLS61OSxXJsskpp6s3wUe2a8IiCIuKWTPbF1Qh+WhLS5wjZ4cYGZ8MuxSRvHHy4lWujU2yWYvWArHYsZf2bFiELS1xJqacw2czuVCdiGRiev3PFjWZA5HJNhePm9l0JP/fgOvJK283m9VXEMmWg70JKkpjrG+sCruUvJTJSGEl0GFmzwEvmy4nlrFV8XIaqsoUCiJZdKBngPamODFtNhmITLa5+DWgDfgKyUtnvmVm/8XM1gdcW84zM+5uieu0VJEsmZicoqtvUOsTApRRT8HdHTiX+pgA6oDnzewLAdaWFza3xDnWf5WroxNhlyKS8966cJXRiSn1EwKUSU/hE2a2F/gC8B1gs7v/e2A78JMB15fz7m6pxR06ezWFJHKrDqamYjdre4vAZHLltQbgX7r76fQ73X3KzH4smLLyx/RvNAd7Erz79uUhVyOS297oGaC6rJi1yyvDLiVvZbJ4bc7LZ6YeO5zdcvLP8qoymmuXzezVIiI372BvgvbmuK5oGCCtEV8CW1riOgNJ5BaNTkxy+OwgW1o1dRSkQEPBzB4ws6NmdszMnpjj8V80s4Nmtt/MXjazjUHWE5YtLbWcuTzMwPBY2KWI5Kw3z11lfNLZ0qyVzEEKLBTMLAY8DTxI8gI9j87xpv91d9/s7ltJNrJ/P6h6wjTdFOvs1cpmkZt1ILWPmM48ClaQI4WdwDF3P+HuY8CzwMPpB7h7+rtkJeAB1hOa9uYaIDkfKiI350B3gtqKElrqloVdSl7L5Oyjm9UMdKfd7gF2zT7IzH4J+AxQCsx5iU8zewx4DGD16tVZLzRotRWltNYv02mpIrfgQG+Czc1xtKlCsIIcKcz1k3vHSMDdn3b39SSvA/1rcz2Ruz/j7jvcfUdjY2OWy1wam5vjM8NfEVmckfFJ3jw/pKmjJRBkKPQArWm3W4C+Gxz/LPATAdYTqs3NtXRfvq5ms8hNOHR2kMkpn9lkUoITZCjsAdrMbJ2ZlQKPAC+kH2BmbWk3Pwy8FWA9oVKzWeTmTa9k1kgheIGFgrtPAI8DLwKHgefcvcvMnjKzh1KHPW5mXWa2n2Rf4WeCqidsajaL3LwDPQkaqspYWVMedil5L8hGM+6+G9g9674n0z7/ZJDfP0rUbBa5eQd6BtjSoibzUtCK5iW0uTmukYLIIg2PTXC8/yrt2gRvSSgUllB7c5wzl4dJDI+HXYpIzjjUN8iUa2fUpaJQWEIzzeY+jRZEMjU95apQWBoKhSXU3pTaRltTSCIZO9g7SENVGbfVlIVdSkFQKCyhuspSWuqWKRREFqGzN0F7c42azEtEobDENjfHdQaSSIauj03y1oUhTR0tIYXCEmtvjnP60jCJ62o2iyzk8Llkk3lTk0JhqSgUltj0bzxdGi2ILGimyayVzEtGobDEpkNBfQWRhXX2JqivLKUprpXMS0WhsMTqKktprlWzWSQTB3sH2dSkJvNSUiiEQM1mkYWNjE/y1nk1mZeaQiEEm1vinLo0zOCIms0i8zl6boiJKVcoLDGFQgjaZ7bR1mhBZD7TU6za82hpKRRCsFmhILKgrr4E8WW6JvNSUyiEoH6m2awL7ojM56CuyRwKhUJI1GwWmd/oxCRHzw2xKXVxKlk6CoWQbG6Jc/LiNTWbRebw1vmrjE+qyRwGhUJI2mdWNmsKSWS2g9ouOzQKhZC8vbJ5IORKRKLnYG+C6vJiVtdXhF1KwVEohETNZpH5dfUmaG9SkzkMgYaCmT1gZkfN7JiZPTHH458xs0NmdsDM/tHM1gRZT9S0N9fQpauwiXyf8ckpDp8b0iZ4IQksFMwsBjwNPAhsBB41s42zDnsd2OHuW4DngS8EVU8UtTclm81XRyfCLkUkMt48P8TYxBSbmnTmURiCHCnsBI65+wl3HwOeBR5OP8DdX3L34dTN7wEtAdYTOZuaa3CHw2c1hSQybfrkCzWZwxFkKDQD3Wm3e1L3zedjwP+b6wEze8zMOsyso7+/P4slhmv6ms1aryDytoO9CarKilm7vDLsUgpSkKEwV4fI5zzQ7KeAHcDvzvW4uz/j7jvcfUdjY2MWSwzXippyGqvL6FSzWWTGwd4EG5tqKCpSkzkMQYZCD9CadrsF6Jt9kJl9EPhV4CF3Hw2wnkhqb1KzWWTaxOQUh88OauooREGGwh6gzczWmVkp8AjwQvoBZrYN+BLJQLgQYC2R1d4c560LVxkZnwy7FJHQHeu/yujElEIhRIGFgrtPAI8DLwKHgefcvcvMnjKzh1KH/S5QBfyZme03sxfmebq8takpzuSUc+TcUNiliIRueiq1XXsehaY4yCd3993A7ln3PZn2+QeD/P65YPoff2dvgq2ttSFXIxKuzt4EFaUx1jVUhV1KwdKK5pA11y6jtqJEfQURkqGwcVUNMTWZQ6NQCJmZ0d4U1xlIUvCmppxDZwd1pbWQKRQiYFNzDUfPJVdxihSqk5euMTw2yUatZA6VQiEC2pvijE1O8dYFNZulcE0v4pxe1CnhUChEwPQeL119mkKSwnWob5DSWBFtt6nJHCaFQgSsXV5JZWmMLm13IQWssy/BnSurKYnpbSlM+tuPgKIiY1NTnE6NFKRAuTudvYNanxABCoWI2NRcw6G+QSan5tweSiSv9Vy5TuL6OJvUTwidQiEi2pviXB+f5OTFq2GXIrLkpvtpOh01fAqFiJj+z6D1ClKIuvoSxIqMu1ZWh11KwVMoRMT6xkrKiot0bQUpSJ29CTY0VlFeEgu7lIKnUIiI4lgR71pVQ6e2u5AC1NU3yCY1mSNBoRAh7c01dPUOMqVmsxSQC4MjXBga1aK1iFAoREh7U5yh0Qm6rwwvfLBInphuMm/S9haRoFCIEDWbpRBN99G051E0KBQipO22Kkpipr6CFJSuvkHWNVRSXV4SdimCQiFSyopjtK2o1hlIUlA6+xIaJUSIQiFi2ptr6OobxF3NZsl/A8Nj9Fy5riZzhCgUIqa9Oc7la2OcTYyEXYpI4A716ZrMUaNQiJjpvV80hSSFYLp/pj2PoiPQUDCzB8zsqJkdM7Mn5nj8vWa2z8wmzOwjQdaSK961qhozXVtBCkNn7yBN8XLqK0vDLkVSAgsFM4sBTwMPAhuBR81s46zDzgAfBb4eVB25pqK0mPWNVXTpDCQpAJ19CTZpE7xICXKksBM45u4n3H0MeBZ4OP0Adz/l7gcAXZw4zaamGo0UJO9dG53g5MVrajJHTJCh0Ax0p93uSd23aGb2mJl1mFlHf39/VoqLsvamOGcTI1y6Ohp2KSKBOXx2EHc1maMmyFCwOe67qfMs3f0Zd9/h7jsaGxtvsazo0zWbpRBMn0yhJnO0BBkKPUBr2u0WoC/A75c3NioUpAB09Q3SUFXKbTVlYZciaYIMhT1Am5mtM7NS4BHghQC/X96orSilpW6ZtruQvNbZN8impjhmc00qSFgCCwV3nwAeB14EDgPPuXuXmT1lZg8BmNm9ZtYD/CvgS2bWFVQ9uWZTU83Mwh6RfDMyPslb54e0M2oEFQf55O6+G9g9674n0z7fQ3JaSWZpb4rzYtd5hkbGtVGY5J03zw8xMeXqJ0SQVjRH1PRVqA6fHQq5EpHs69L2FpGlUIio6d+gtIhN8lFXX4Lq8mJW11eEXYrMolCIqBXVZTRUlekMJMlLnb2DbFxVoyZzBCkUIsrM2NRUo43xJO9MTjlHzg2qnxBRCoUIa2+u4diFq4yMT4ZdikjWnOi/ysj4lM48iiiFQoRtaoozMeW8eV7NZskf0+tv2rURXiQpFCJM211IPurqHaSsuIj1jZVhlyJzUChE2Or6CqrLi3UGkuSVrr5B7lpZTXFMbz9RpJ9KhJkZG1fV0NmrkYLkB3enS9dQiDSFQsS1N8c5cm6QiUldckJyX8+V6wyOTKjJHGEKhYjb1FTDyPgUJy5eC7sUkVvWpWsyR55CIeK0slnySWfvILEi466V1WGXIvNQKETc+sZKyoqL6FJfQfJAV1+CDY1VlJfEwi5F5qFQiLjiWBF3rarRtRUkL3T1DaqfEHEKhRwwfW0F95u6mqlIJFwYGuHC0OjMlQUlmhQKOaC9Kc7gyAQ9V66HXYrITXt7u2w1maNMoZADpofb2hxPctn0lQQ1Uog2hUIOuHNlNbEi03YXktM6exOsrq+gRlcSjDSFQg4oL4nRtqJKzWbJaWoy5waFQo7Y2FSjkYLkrMT1cc5cHlY/IQcEGgpm9oCZHTWzY2b2xByPl5nZN1KPv2pma4OsJ5e1N8XpHxrlwuBI2KWILJr6CbkjsFAwsxjwNPAgsBF41Mw2zjrsY8AVd98AfBH4naDqyXXaRlty2dvbWygUoi7IkcJO4Ji7n3D3MeBZ4OFZxzwMfDX1+fPAB0wXbZ3TxplQUF9Bcs+hvkEaq8tYUV0edimygOIAn7sZ6E673QPsmu8Yd58wswSwHLiYfpCZPQY8lro5amadgVQcDQ3Mev3pPv478PElLCYAN3x9OS6fXxtk4fXZr2WpkmDk+8/vzkwOCjIU5vqNf/aS3EyOwd2fAZ4BMLMOd99x6+VFk15f7srn1wZ6fbnOzCbyJwYAAAV4SURBVDoyOS7I6aMeoDXtdgvQN98xZlYMxIHLAdYkIiI3EGQo7AHazGydmZUCjwAvzDrmBeBnUp9/BPima4MfEZHQBDZ9lOoRPA68CMSAP3L3LjN7Cuhw9xeArwD/28yOkRwhPJLBUz8TVM0RodeXu/L5tYFeX67L6PWZfjEXEZFpWtEsIiIzFAoiIjIjZ0LBzFrN7CUzO2xmXWb2ybBryhYzKzez18zsjdRr+42wawqCmcXM7HUz+5uwa8k2MztlZgfNbH+mp/7lEjOrNbPnzexI6v/gD4RdU7aY2Z2pn9v0x6CZfSrsurLFzD6del/pNLM/NbMbriDMmZ6Cma0CVrn7PjOrBvYCP+Huh0Iu7ZalVnFXuvtVMysBXgY+6e7fC7m0rDKzzwA7gBp3/7Gw68kmMzsF7HD3vFz8ZGZfBf7Z3b+cOpuwwt0Hwq4r21Lb8/QCu9z9dNj13Cozayb5frLR3a+b2XPAbnf/4/m+JmdGCu5+1t33pT4fAg6TXBGd8zzpaupmSeojN9I6Q2bWAnwY+HLYtcjimFkN8F6SZwvi7mP5GAgpHwCO50MgpCkGlqXWglXwzvVi3ydnQiFdajfVbcCr4VaSPamplf3ABeDv3T1vXlvKfwX+AzAVdiEBceDvzGxvaluWfHI70A/8r9T035fNrDLsogLyCPCnYReRLe7eC/wecAY4CyTc/e9u9DU5FwpmVgX8OfApd8+bLUPdfdLdt5Jc+b3TzNrDrilbzOzHgAvuvjfsWgJ0n7vfQ3JX4F8ys/eGXVAWFQP3AP/d3bcB14B3bIWf61LTYg8BfxZ2LdliZnUkNx5dBzQBlWb2Uzf6mpwKhdR8+58DX3P3vwi7niCkhuXfAh4IuZRsug94KDXv/izwfjP7k3BLyi5370v9eQH4S5K7BOeLHqAnbfT6PMmQyDcPAvvc/XzYhWTRB4GT7t7v7uPAXwDvudEX5EwopJqxXwEOu/vvh11PNplZo5nVpj5fRvIHeSTcqrLH3T/n7i3uvpbk8Pyb7n7D31ZyiZlVpk5+IDWt8i+AvNnJ193PAd1mNr3L5geAnD/BYw6PkkdTRylngHebWUXqPfQDJPux8wpyl9Rsuw/4aeBgau4d4D+5++4Qa8qWVcBXU2c+FAHPuXvenbaZx24D/jJ1KZBi4Ovu/rfhlpR1Hwe+lppiOQH8bMj1ZJWZVQAfAn4h7Fqyyd1fNbPngX3ABPA6C2x3kTOnpIqISPByZvpIRESCp1AQEZEZCgUREZmhUBARkRkKBRERmaFQEFkCZvaLZvZvw65DZCE6JVVERGZopCAyi5nda2YHUte5qEztRd8+65gfN7NXUxvE/YOZ3Za6/w/M7MnU5z9iZt82syIz+7yZfTZ1/yfM7FDqezy79K9QZH4aKYjMwcx+EygHlpHc9+e3Zz1eBwy4u5vZzwHvcvdfTq2M3QM8DvwP4Efd/biZfR646u6/Z2Z9wDp3HzWz2jzehlpyUC5tcyGylJ4i+eY+AnxijsdbgG+kLv5UCpwEcPdhM/t54NvAp939+Bxfe4DklhF/BfxVEMWL3CxNH4nMrR6oAqqBcjP7renLNaYe/0Pgv7n7ZpL75aRf4nAzcInkVsVz+TDwNLAd2Ju6+IlIJCgUROb2DPDrwNeA33H3X3X3ralrXgDESV62EeBnpr/IzNYAv0zyIlAPmtmu9Cc1syKg1d1fInnRoVqS4SMSCfoNRWSW1KmjE+7+9dTOta+Y2fvd/Ztph30e+DMz6wW+B6xL2979s+7eZ2YfA/7YzO5N+7oY8CdmFgcM+KJ6ChIlajSLiMgMTR+JiMgMhYKIiMxQKIiIyAyFgoiIzFAoiIjIDIWCiIjMUCiIiMiM/w8/Zhy4J5JD3QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.linspace(0, 10, 100)\n", "plt.plot(x, np.sin(x))\n", "\n", "plt.xlim([2, 8])\n", "plt.ylim([0, 0.75])\n", "\n", "plt.xlabel('x-axis')\n", "plt.ylabel('y-axis')\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.linspace(0, 10, 100)\n", "\n", "plt.plot(x, np.sin(x), label=('sin(x)'))\n", "plt.plot(x, np.cos(x), label=('cos(x)'))\n", "\n", "plt.ylabel('f(x)')\n", "plt.xlabel('x')\n", "\n", "plt.legend(loc='lower left')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Scatter Plots" ] }, { "cell_type": "code", "execution_count": 85, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "rng = np.random.RandomState(123)\n", "x = rng.normal(size=500)\n", "y = rng.normal(size=500)\n", "\n", "\n", "plt.scatter(x, y)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Bar Plots" ] }, { "cell_type": "code", "execution_count": 86, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# input data\n", "means = [1, 2, 3]\n", "stddevs = [0.2, 0.4, 0.5]\n", "bar_labels = ['bar 1', 'bar 2', 'bar 3']\n", "\n", "\n", "# plot bars\n", "x_pos = list(range(len(bar_labels)))\n", "plt.bar(x_pos, means, yerr=stddevs)\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Histograms" ] }, { "cell_type": "code", "execution_count": 87, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "rng = np.random.RandomState(123)\n", "x = rng.normal(0, 20, 1000) \n", "\n", "# fixed bin size\n", "bins = np.arange(-100, 100, 5) # fixed bin size\n", "\n", "plt.hist(x, bins=bins)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 88, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "rng = np.random.RandomState(123)\n", "x1 = rng.normal(0, 20, 1000) \n", "x2 = rng.normal(15, 10, 1000)\n", "\n", "# fixed bin size\n", "bins = np.arange(-100, 100, 5) # fixed bin size\n", "\n", "plt.hist(x1, bins=bins, alpha=0.5)\n", "plt.hist(x2, bins=bins, alpha=0.5)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Subplots" ] }, { "cell_type": "code", "execution_count": 89, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "\n", "import matplotlib.pyplot as plt\n", "\n", "x = range(11)\n", "y = range(11)\n", "\n", "fig, ax = plt.subplots(nrows=2, ncols=3,\n", " sharex=True, sharey=True)\n", "\n", "for row in ax:\n", " for col in row:\n", " col.plot(x, y)\n", " \n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Colors and Markers" ] }, { "cell_type": "code", "execution_count": 90, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.linspace(0, 10, 100)\n", "plt.plot(x, np.sin(x),\n", " color='orange',\n", " marker='^',\n", " linestyle='')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Saving Plots" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The file format for saving plots can be conveniently specified via the file suffix (.eps, .svg, .jpg, .png, .pdf, .tiff, etc.). Personally, I recommend using a vector graphics format (.eps, .svg, .pdf) whenever you can, which usually results in smaller file sizes than bitmap graphics (.jpg, .png, .bmp, tiff) and does not have a limited resolution." ] }, { "cell_type": "code", "execution_count": 91, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "x = np.linspace(0, 10, 100)\n", "plt.plot(x, np.sin(x))\n", "\n", "plt.savefig('myplot.png', dpi=300)\n", "plt.savefig('myplot.pdf')\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Resources" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are no reading assignments for this lecture. However, you should run this notebook on your computer from top to bottom at your own pace and make sure that you are comfortable with the different commands, most of which you may need for the problem sets." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy and Matplotlib reference material:\n", "\n", "- [The official NumPy documentation](https://docs.scipy.org/doc/numpy/reference/index.html)\n", "- [The official Matplotlib Gallery](https://matplotlib.org/gallery/index.html)\n", "- [The official Matplotlib Tutorials](https://matplotlib.org/tutorials/index.html)\n", "\n", "\n", "Optional references books for using NumPy and SciPy. You are not expected to read this for this class, but I am listing it in case you are interested in learning NumPy for your projects.\n", "\n", "- Rougier, N.P., 2016. [From Python to NumPy](http://www.labri.fr/perso/nrougier/from-python-to-numpy/).\n", "- Oliphant, T.E., 2015. [A Guide to NumPy: 2nd Edition](https://www.amazon.com/Guide-NumPy-Travis-Oliphant-PhD/dp/151730007X). USA: Travis Oliphant, independent publishing.\n", "- Varoquaux, G., Gouillart, E., Vahtras, O., Haenel, V., Rougier, N.P., Gommers, R., Pedregosa, F., Jędrzejewski-Szmek, Z., Virtanen, P., Combelles, C. and Pinte, D., 2015. [SciPy Lecture Notes](http://www.scipy-lectures.org/intro/numpy/index.html).\n" ] } ], "metadata": { "anaconda-cloud": {}, "kernelspec": { "display_name": "Python 3", "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.7.3" }, "toc": { "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }