B - Numpy and Matplotlip.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table align=\"left\">\n",
    "  <td>\n",
    "    <a href=\"https://colab.research.google.com/github/fmottes/unito-neural-networks/blob/master/B%20-%20Numpy%20and%20Matplotlip.ipynb\">\n",
    "      <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\" style=\"width:175px;\"/>\n",
    "    </a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> **Neural Networks** (MFN0824) </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lectures: _Dr. Matteo Osella_\n",
    "### Notebooks: _Francesco Mottes_\n",
    "<br>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The material presented in the following is not meant to be a complete introduction to the Python programming language or to programming in general. The purpose of this notebook is to review some basic functionalities of the Python3 language, as well as some of the libraries that are most often used in Machine Learning and scientific applications in general. In particular, we will try to show many of the functionalities that will be needed for the practicals of the Neural Networks course.\n",
    "\n",
    "Further in-depth information, as well as more comprehensive introductions, can be found online quite easily. Below is a (short and incomplete) list of references that can guide further research into the presented topics. Other relevant references will be given when needed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python references:\n",
    "- Python programming introductory book: Think Python (FREE: https://greenteapress.com/wp/think-python-2e/)\n",
    "- Python3 Docs: https://docs.python.org/3/\n",
    "- Python stilistic guide: https://www.python.org/dev/peps/pep-0008/\n",
    "\n",
    "### Python modules references:\n",
    "- Numpy Docs: https://numpy.org/\n",
    "- Matplotlib Docs: https://matplotlib.org/\n",
    "- Scikit-learn Docs: https://scikit-learn.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> **B - Numpy and Matplotlib Review** </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is a library that provides many pre-implemented high-performance data types (for us mainly 1D and 2D **arrays**) and algorithms for numerical computation. Many other libraries, included those used for deep learning, use numpy arrays and algorithms extensively, so it is of paramount importance to understand the basics of it.\n",
    "\n",
    "Matplotlib is one of the most used plotting libraries for python. It is based on numpy, is very powerful and flexible but it is also very simple to learn its basic usage. We will use this library for all the plots you will find in course notebooks. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center> **Numpy** </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np #this is the standard name given to numpy on import"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fundamental data type of numpy is the **array**, which is basically a python list \"on steroids\". Arrays behave pretty much like lists in python, but have many additional features and methods. They support indexing in exactly the same way as lists, but all the elements of a numpy array must be of the same type, differently from a list. You can iterate over a numpy array, you can have a numpy array containing other numpy arrays (2D arrays). Let's see some examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Creation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([], dtype=float64)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#array from empty list\n",
    "a = np.array([])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#array from list\n",
    "a = np.array([1,2,3])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "#check the shape of the array\n",
    "print(a.shape)\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "#2D array from list\n",
    "a = np.array([[1,2,3],[4,5,6]])\n",
    "\n",
    "print(a)\n",
    "print()\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1d array of zeros\n",
    "a = np.zeros(10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#2d array of ones\n",
    "a = np.ones((2,4))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 6, 8])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#range with fixed step size - same syntax as range()\n",
    "a = np.arange(2,10,2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.        ,  2.57142857,  3.14285714,  3.71428571,  4.28571429,\n",
       "        4.85714286,  5.42857143,  6.        ,  6.57142857,  7.14285714,\n",
       "        7.71428571,  8.28571429,  8.85714286,  9.42857143, 10.        ])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#range with fixed equally (linearly) spaced number of points\n",
    "a = np.linspace(2,10,num=15)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.        ,   1.27427499,   1.62377674,   2.06913808,\n",
       "         2.6366509 ,   3.35981829,   4.2813324 ,   5.45559478,\n",
       "         6.95192796,   8.8586679 ,  11.28837892,  14.38449888,\n",
       "        18.32980711,  23.35721469,  29.76351442,  37.92690191,\n",
       "        48.32930239,  61.58482111,  78.47599704, 100.        ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#range with fixed equally (logarithmically) spaced number of points\n",
    "a = np.logspace(0,2,num=20) #20 logarithmically spaced points from 10**0=1 to 10**2=100\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64 [0 1 2 3 4 5 6 7 8 9]\n",
      "float64 [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]\n"
     ]
    }
   ],
   "source": [
    "#change data type of array\n",
    "a = np.arange(10)\n",
    "\n",
    "print(a.dtype, a)\n",
    "\n",
    "a = a.astype(float)\n",
    "print(a.dtype, a)\n",
    "\n",
    "#NOTE: we did NOT write a.dtype = int !!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Indexing, Transposing, Reshaping**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reshape a 1d array into a 2d one\n",
    "a = np.arange(10)\n",
    "\n",
    "a = a.reshape(2,5) #note that reshape returns a COPY of the original array\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#flatten a 2d array\n",
    "a.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 5],\n",
       "       [1, 6],\n",
       "       [2, 7],\n",
       "       [3, 8],\n",
       "       [4, 9]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#transpose a 2d array\n",
    "a.T\n",
    "\n",
    "#equivalent to:\n",
    "# a.transpose()\n",
    "# np.transpose(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "#INDEXING\n",
    "#very similar to list indexing, but indexing can be composed in case of 2d arrays\n",
    "\n",
    "#get first row of a\n",
    "print(a[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n"
     ]
    }
   ],
   "source": [
    "#get second element of first row\n",
    "print(a[0][1], a[0,1]) #the second way is faster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 5]\n"
     ]
    }
   ],
   "source": [
    "#get first column of a\n",
    "print(a[:,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [5 6 7]]\n"
     ]
    }
   ],
   "source": [
    "#drop the last two columns of a\n",
    "print(a[:,:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Array methods**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:** the dimensions of the arrays are called *axis*. *axis=0* moves through the rows of the array, so if something is done *along axis=0* means it is done column by column, on the contrary, operations carried on *along axis=1* are done row by row. It can be pretty counter-intuitive in the beginning, but we will see some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "a = a.reshape(2,5) #note that reshape returns a COPY of the original array\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.5\n",
      "[2.5 3.5 4.5 5.5 6.5]\n",
      "[2. 7.]\n"
     ]
    }
   ],
   "source": [
    "#calculate the mean along the two axes\n",
    "print(a.mean()) #flattened array\n",
    "print(a.mean(axis=0)) #column mean\n",
    "print(a.mean(axis=1)) #row mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.8722813232690143\n",
      "9\n",
      "0\n",
      "45\n"
     ]
    }
   ],
   "source": [
    "# other functions - same rules for axes\n",
    "print(a.std()) #standard deviation\n",
    "print(a.max())\n",
    "print(a.min())\n",
    "print(a.sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "[0 6]\n",
      "[[0 5]\n",
      " [1 6]\n",
      " [2 7]\n",
      " [3 8]\n",
      " [4 9]]\n",
      "[10. 35.]\n"
     ]
    }
   ],
   "source": [
    "#since a is a 2d array we can use some functionalities related to matrices as well\n",
    "print(a.trace())\n",
    "print(a.diagonal())\n",
    "print(a.T)\n",
    "\n",
    "b = np.ones(5)\n",
    "print(a.dot(b)) #matrix product: 2x5 dot 5x1 = 2x1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE:** numpy also provides a \"matrix\" data type to deal more specifically with matrix operations, but the array data type will be well suited and sufficient to address the topics of thi course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Vectorized Operations**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy provides a fast way to carry out element-wise operations on arrays. Almost all normal operations are interpreted to be element-wise operations when a numpy array is involved, if this makes sense. Also all functions provided by numpy are able to perform such a trick, which makes calculations faster both to write and to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#vectorized sum/subtraction\n",
    "a+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  3,  6,  9, 12],\n",
       "       [15, 18, 21, 24, 27]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#vectorized multiplication/division\n",
    "a*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.16666667, 0.28571429, 0.375     , 0.44444444],\n",
       "       [0.5       , 0.54545455, 0.58333333, 0.61538462, 0.64285714]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sum/subtract/mult/divide arrays with same shape\n",
    "b = a+5\n",
    "a/b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 1.        , 1.41421356, 1.73205081, 2.        ],\n",
       "       [2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.        ]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#square root\n",
    "np.sqrt(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Random Generators**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numpy.random module provides many useful functions based on random number generation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.1087501 , 0.29837419, 0.68346114, 0.16857647, 0.88307322])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#uniformly distributed random array\n",
    "a = np.random.uniform(size=5)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.74537663,  0.35084188,  0.19156066, -1.4429529 ,  0.0982341 ])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#gaussian distributed random array\n",
    "a = np.random.normal(size=5)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[3 0 6 4 5 8 1 2 7 9]\n"
     ]
    }
   ],
   "source": [
    "#shuffle array elements\n",
    "a = np.arange(10)\n",
    "print(a)\n",
    "\n",
    "np.random.shuffle(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n",
      "\n",
      "[[ 5  6  7  8  9]\n",
      " [10 11 12 13 14]\n",
      " [ 0  1  2  3  4]]\n"
     ]
    }
   ],
   "source": [
    "#shuffle rows of an array\n",
    "a = np.arange(15).reshape(3,5)\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "np.random.shuffle(a)\n",
    "print(a)\n",
    "\n",
    "# NOTE: shuffle() acts ONLY on axis=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 6 7 8 8 2 0 7 5 7 4 9 1 4 6]\n",
      "[7 6 2 9 0]\n"
     ]
    }
   ],
   "source": [
    "#draw samples from array elements\n",
    "a = np.arange(10)\n",
    "\n",
    "#with replacement\n",
    "print(np.random.choice(a,15))\n",
    "\n",
    "#without replacement\n",
    "print(np.random.choice(a,5,replace=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <center> **Matplotlib** </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see in the following examples, matplotlib is pretty straightforward to use for standard plots. At the same time it is nearly impossible to make a complete tour of all the possible settings, as things can get much more messy than this when you try to get more fancy on the details. On the other hand, matplotlib has an excellent documentation and you can find any sort of graphic trick on Google to make your plots look unique. You are highly encouraged to dig deeper into the details if you feel like doing so, but the following basics are pretty much everything we will need during this course. More advanced details will be used and explained if needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt #standard way to import matplotlib basic functionalities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Functions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Straight Lines')"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot a line\n",
    "\n",
    "x = np.linspace(-5,5, 10) #create x values\n",
    "\n",
    "y = 3*x\n",
    "plt.plot(x,y) #plot a simple line with default params\n",
    "\n",
    "y = 2*x\n",
    "plt.plot(x,y,'--') #another dashed line\n",
    "\n",
    "y = x\n",
    "plt.plot(x,y,'g^:') #green dotted line with triangles on data points\n",
    "\n",
    "y = 4*x+5\n",
    "plt.plot(x,y,'ko') #only round data points, black\n",
    "\n",
    "plt.grid() #show grid\n",
    "\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Straight Lines')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f17146c0b70>"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#create figure explicitly\n",
    "fig, ax = plt.subplots(figsize=(8,6))\n",
    "\n",
    "x = np.linspace(-5,5, 30) #create x values\n",
    "\n",
    "\n",
    "y = x**2\n",
    "ax.plot(x,y,'rs', label='Quadratic')\n",
    "\n",
    "y=.5*x**3\n",
    "ax.plot(x,y,'b', label='Cubic')\n",
    "\n",
    "ax.set_title('Polynomials', fontsize=20)\n",
    "\n",
    "ax.set_xlabel('x', fontsize=15)\n",
    "ax.set_ylabel('y', fontsize=15)\n",
    "\n",
    "ax.grid()\n",
    "\n",
    "ax.legend(fontsize=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Scatterplots**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f17139f31d0>"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#generate bunch of random but correlated data\n",
    "x = np.linspace(-5,5,70) #create x values\n",
    "y = 2*x+np.random.normal(0,2,size=x.shape[0])\n",
    "\n",
    "#create figure explicitly\n",
    "fig, ax = plt.subplots(figsize=(8,6))\n",
    "\n",
    "ax.plot(x,y,'o', label='Random data')\n",
    "\n",
    "\n",
    "ax.set_title('Scatterplot', fontsize=20)\n",
    "\n",
    "ax.set_xlabel('x', fontsize=15)\n",
    "ax.set_ylabel('y', fontsize=15)\n",
    "\n",
    "ax.grid()\n",
    "\n",
    "ax.legend(fontsize=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Histograms**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f17139be400>"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#generate bunch of random normal data\n",
    "data = np.random.normal(size=10000)\n",
    "\n",
    "#create figure explicitly\n",
    "fig, ax = plt.subplots(figsize=(8,6))\n",
    "\n",
    "\n",
    "ax.hist(data, bins=25, density=True, label='Random normal data') #density keyword takes care of normalizing the histogram\n",
    "\n",
    "\n",
    "ax.set_title('Histogram', fontsize=20)\n",
    "\n",
    "ax.set_xlabel('x', fontsize=15)\n",
    "ax.set_ylabel('y', fontsize=15)\n",
    "\n",
    "\n",
    "ax.legend(fontsize=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Multiple plots**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAt4AAAFXCAYAAACVw0nSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3X24nHV56PvvzTLq8qUGS9qaBZioNFs0LWlXsZ70KLrVxNJCpLUC1kJrS+2RtkdtdsPWAxQ3hyinWvcubU2VbWtFpAoxbVJTNVL6opVgQAg0NWKUrFiJYrRKxCTc54/nWTCZzKw1s9a8PDPz/VzXXGvN8zJzz0B+c6/f3M/9i8xEkiRJUncd1+8AJEmSpFFg4i1JkiT1gIm3JEmS1AMm3pIkSVIPmHhLkiRJPWDiLUmSJPWAibc0YCLi5oiwD6ikSouIjIib+x2HVCUm3uq6iBiLiN+IiH+IiAci4lBE3B8Rn4+I90TEWT2MpekHQUQsKfe/r1fx9JMfipJmU44TM/6hHxF7yuOWdPB5R2o81uh4TL8D0HCLiDHgb4HVwAFgM7AXeCrwTOB84L8Am/oVoySpK54NPNjvIKQqMfFWt51HkXTfAbwwM79VuzMingA8rx+BSZK6JzP/rd8xSFVjqYm67f8of76vPukGyMwHM/NT9dsj4lUR8cmyNOV75VeZH4yIyZpjnhIRayNiW0TsjYjvR8T+iNgUET9d93gX1nxd+sLpr0/L2+URcTnwpXL/BXX7L6x7rFURsSUivh4RD0XEFyPi6ohY2OB17ClvPxAR7yh/P1Q+H+VzZ0ScEREXRMSOiDhYluJcGxE/0uobHRHHRcTrIuLWiPhORHy3/P23IuK4muNmfC9afT5JmkmjcraIeHJE/D8RcVdEfDsi/rMcQz8UET9ZHnM5LYzHrY55dc//6oj4XM04+/6IWNzo2plyXJ7+jDg9IjaXn0mPlNVExIsiYkNE3F2+noPla7ssIh7f4Plrx/zzIuK2iHgwIvaVnxGPK497cRnTtyPim2WcPzjH/xSqEGe81W3fKH/+aCsHR0QA/xu4APg6cCOwHzgReBGwC9heHv5s4ErgFooSlm8CJwNnAS+PiJ/PzI+Vx94O/AFwGfBl4H01T3tz+XMh8LsUs/Mba/bfXhPfpeXjPEBRQnM/8GPA7wE/GxHPz8xv172sxwLbKMpr/h74No9+qEx7A/Ay4EPAx4CfAX4VOCMinpeZ+xu/Y0d5P0Xpzn3Ae4AEXgH8Sfl4r27jvZCkjirH949RTMh8mmKcOgycBJwB/CNwG8U4NOt4TOtj3vTzrwXeTvFZ8RfAt4CXAv9c/t7M84FLgH8CrgVOAL5f7vt9inLJf6H4HHo8sBK4nGL8fklmHmnwmL8NvLx8bTdTjP9vAJ4aER8Fri8fb0P5fv1y+bwvnyFODYLM9OatazdgBcUA9TDFIHkO8PQZjr+IYvD8LPCUun1jwNNq7j8FOKHBY5wI7APuabAvgZubPPeScv/7mux/Ubn/X4CFdfsuLPe9s277nnL7J4AnNnjMy8v93wdW1O17Z7nvvXXbby7+6R617bzy2M8BT6rZ/kSKP1QSOL/V98KbN2/eMh8ZJ7Icq5rdDpTHLGlw7s0195eX225q8DzHAcfX3J9tPG5rzAOeARyimMg5qWZ7AB+cfp11z3FGzev/zSZxPAOIBtvfWp73qrrt02P+t4Bn12x/HLATOEIxYfXCuvfm4+V5p/X7/wlv87tZaqKuyswdFH+pf638+RFgT0R8IyJuioifrzvlt8ufv5l1pSmZeSQzv1pz/1uZ+fUGz7kX+DDwXyLi5A6+nN8pf/5GZh6oe873UczEvLr+pNKbMvO7Mzz2+8v3qtblFIPz+dNfP87g18qf6zLzOzVxfZdiRgbg12d5DElq5rIZbk9p87EO1m/IzIcz85ttPEa7Y975FN/y/6/MvK/m+ATWUSS8zdyeme9utCMz7y0fo94flT9XNXnM/5mZ99Q8zkMU33geB2zOzH+o2fcw8Ffl3R+fIU4NAEtN1HWZeUNE3EQxY/wzFLPgPwOsAdZExF9SzBg/AXgu8LUGSWhDEbGS4uvI5wM/RFHWUWsC+EoHXgblcxwCXhkRr2yw/7HAooj4wcz8Rs327wGfn+Wx/6F+Q2Z+KyJuB15IUVZz+zFnPeonKL5VuLnJYx+heN8lqW2ZGc32RcQe4OktPMzdFOPYeRHxdOCjFOUb2zPz+zOeeax2x7zp3/+p/uDM/HJE3Ecxy97IZ5sFERFPpPgMegVFSeWTKWbRp000OXV7g237yp+3Ndg3Vf48sVksGgwm3uqJzDxEUd/89/BIm8FfoKiX+xXgJuDW8vCpRo9RLyJeQTGz/T2Kr+G+CHyXYjA+gyJhnW2muB0/SPFv5rJZjnsSj9a2A9zfZEak1teabP+P8udsM0pPAR5o9OGVmYcj4usUf5hIUl9k5pGIeDFwKfCLwNvKXf8ZEX8BXFI7ez2Ldse86TG02Vj7NZon3v/RaGNELKC4fud04C6KGev9FBM0UHxWNPsMalRTfriFfQuaPJ4GhIm3+iKLi01uiIjlwFuAF1Mkz9B8hqDeWylqoydrv7IDiIh3UyTenfQt4LjMfGqb57WyyuQPN9k+3dVkpgt/pvc/NSIWlH/kPCIiHkNxUU79RZ+S1FNlOckbgDdExLMoxunfBC6muKDyNS0+VLtj3vTvP0xRS12v2RgMzcfwsymS7r/IzAvrYngas0/SaARZ461++8/yZ5S1eXcBPxwRrZRFPAu4u0HSfRxFKUsjD1NcpNnIdI1fs/2fAY6PiOe0EFu7jvkjISKeApxGMaN/zzFnHG0Hxb/nFzTY9wKK1/S5uu0zvReS1FWZuTsz30sx/n2HIpGdNtt43O6YN12+eMxnQ1n2clLrkT/iWeXPjzTY1+mJHw0JE291Vdmn9KWNeqqWPap/o7x7S/nzf5Y/310mnrXHH1fOIkzbA5wSEYtrjgmKWYZTm4T0DZoPsN+kmNlodkHmO8uff177nDXP/cSo6x/ehtc0+GPjcoqvRz9YXngzk2vLn1dFsSjRdExPANaXd99bd85M74UkdVRELG0ycXE8RUlG7UWXs43H7Y5511GUa/x2RJxUc3wAVzG3SYg95c8zajdGxDN4tIxGOoqlJuq251FcePIfEfFPPNq/eilwJjBOcYHNh8vt76GYkfgV4AtlP9P9wGKKcpRrKRJSKBLhPwN2RMRHKOrqVlIk3X8D1HdMAfgkcG5E/A3FBSyHgVsy85bM/E5E/Cvwf0bEB4B/p5h12ZSZn8/MT0bEOopB+gsRsaV8PU+iuLDohRQX7qyew/v0d8A/R8QNwFfL9+BnKAb2dbOdnJnXRcTZwC8BOyNiI8WH1hqK9/qGzPxAq+/FHOKXpNn8OHBTRNxG8e3mPmARxUz3AmqS1RbG47bGvMz8YrkOw/8L3BERH+LRPt5PpegX/mNtvp6/AXYDbyzLJndQ/KHwcxQ9uDvZVUvDot/9DL0N941iRvX1FBdP7qKos/s+RXK5haLF4HENzns1xZXp36IotfgS8AHgJ+qOu5DiKvnvUiy4cxNFr9jLKQbhM+qO/yGKmY+vUQziCVxes/9ZFIPpNyhKMRK4sO4xfga4geJD4/sUfxjcDryDot689tg9wJ4Z3p9H4qx5LQfLx/zf1PQtrznnZur6zZbbjwP+L4qr5R8sb7eV73+j93jG98KbN2/eaNDfusExe2itj/eJFInvP1NcsPgQsJdi4uHlDR53xvG43TGvPOc1FAny98px9q8oJnbuAg7UHXvGbOMixWfcByiaAhykqB//bxQTm8esldDss6ncd2Gjz5xWY/E2GLco/4NK6oMolka+DHhRZt7c32gkafRExA9QTEDcnpnP73c8Gm7WeEuSpKEXEYvKFoC12x4D/CHFUu839SUwjRRrvCVJ0ij4BeCKiPgEcB9FbfcLKBa+uR34X32MTSPCxFuSJI2Cf6W4AP4FFAuiQXH90JXA2zLzmKXspU6rXI13RFxLcUXw/Zn53HLb5RRt5/aXh/33zNzSnwglSZKk9lWxxvt9NG7H9s7MPK28mXRLkiRpoFSu1CQzb4mIJfN9nBNOOCGXLJn3w0hSX9x2221fz8xF/Y6jVxyzJQ2yVsfsyiXeM7g4In6Fol/nmzLzmzMdvGTJErZv396byCSpwyLiy/2OoZccsyUNslbH7CqWmjTyp8AzgdMoFl75w0YHRcRFEbE9Irbv37+/0SGSJElSXwxE4p2ZX8vMI5n5MPDnwOlNjtuQmZOZOblo0ch8QytJkqQBMBCJd0Q8rebuKyiWdpUkSZIGRuVqvCPig8AZwAkRsZdiOe0zIuI0IIE9wG/2LUBJkiRpDiqXeGfmeQ02v7fngUiSJEkdNBClJpIkSdKgM/GWJEmSeqBypSaSVEUbd0xx9dZd7DtwkMULx1m7ahlrVkz0OyxJ0gAx8ZakWWzcMcUlN97JwUNHAJg6cJBLbrwTwORbktQyS00kaRZXb931SNI97eChI1y9dVefIpIkDSITb0maxb4DB9vaLklSI5aaSNIsFi8cZ6pBkr144XgfoumdiFgNvAsYA96TmeubHPeLwF8DP5WZ28ttlwCvBY4Av5OZW3sTtYbRknWbWz52z/ozuxiJND/OeEvSLNauWsb4grGjto0vGGPtqmV9iqj7ImIMuAZ4OXAqcF5EnNrguCcDvwP8a822U4FzgecAq4E/KR9PkkaaibckzWLNigmuOmc5EwvHCWBi4ThXnbN82C+sPB3YnZn3Zub3geuBsxsc91bg7cD3aradDVyfmQ9l5peA3eXjSdJIs9REklqwZsXEsCfa9SaA+2ru7wWeV3tARKwATsrMv42I36s79zN1547Um6f+sSxFVeaMtySpkWiwLR/ZGXEc8E7gTe2eW/MYF0XE9ojYvn///jkHKkmDwsRbktTIXuCkmvsnAvtq7j8ZeC5wc0TsAX4a2BQRky2cC0BmbsjMycycXLRoUYfDl6TqMfGWJDVyK3BKRCyNiMdSXCy5aXpnZn4rM0/IzCWZuYSitOSssqvJJuDciHhcRCwFTgE+2/uXIEnVYo23JOkYmXk4Ii4GtlK0E7w2M3dGxBXA9szcNMO5OyPiBuBu4DDw+sw80ux4SRoVJt6SpIYycwuwpW7bpU2OPaPu/pXAlV0LTpIGkIm3pJG0cccUV2/dxb4DB1m8cJy1q5aNWtcSSVKPmXhLGjkbd0xxyY13cvBQUf0wdeAgl9x4J4DJtySpa7y4UtLIuXrrrkeS7mkHDx3h6q27+hSRJGkUmHhLGjn7Dhxsa7skSZ1g4i1p5CxeON7WdkmSOsHEW9LIWbtqGeMLxo7aNr5gjLWrlvUpIknSKPDiSkkjZ/oCSruaSJJ6ycRb0khas2LCRFuS1FOWmkiSJEk9YOItSZIk9YCJtyRJktQDJt6SJElSD5h4S5IkST1g4i1JkiT1gIm3JEmS1AP28ZYkSSNpybrNLR+7Z/2ZXYxEo8IZb0mSJKkHTLwlSZKkHjDxliRJknrAxFuSJEnqAS+ulDQQNu6Y4uqtu9h34CCLF46zdtUy1qyY6HdYkiS1zMRbUuVt3DHFJTfeycFDRwCYOnCQS268E8DkW5I0MCw1kVR5V2/d9UjSPe3goSNcvXVXnyKSJKl9Jt6SKm/fgYNtbVdnRMTqiNgVEbsjYl2D/a+LiDsj4vaI+KeIOLXcviQiDpbbb4+IP+t99JJUPZaaSKq8xQvHmWqQZC9eON6HaEZDRIwB1wAvBfYCt0bEpsy8u+aw6zLzz8rjzwLeAawu930xM0/rZcySVHXOeEuqvLWrljG+YOyobeMLxli7almfIhoJpwO7M/PezPw+cD1wdu0BmfntmrtPBLKH8UnSwHHGW1LlTV9AaVeTnpoA7qu5vxd4Xv1BEfF64I3AY4EX1+xaGhE7gG8Db8nMf+xirJI0ECqXeEfEtcDPAfdn5nPLbU8FPgQsAfYAv5SZ3+xXjJJ6b82KCRPt3ooG246Z0c7Ma4BrIuJ84C3ABcBXgZMz8xsR8ZPAxoh4Tt0MORFxEXARwMknn9zp+CWpcqpYavI+Hq0RnLYO+GRmngJ8srwvSS3buGOKleu3sXTdZlau38bGHVP9Dqnq9gIn1dw/Edg3w/HXA2sAMvOhzPxG+fttwBeBH60/ITM3ZOZkZk4uWrSoY4FLUlVVbsY7M2+JiCV1m88Gzih//wvgZuD3exaUpIFmH/A5uRU4JSKWAlPAucD5tQdExCmZ+YXy7pnAF8rti4AHMvNIRDwDOAW4t2eRayAsWbe53yFIPVfFGe9GfjgzvwpQ/vyhRgdFxEURsT0itu/fv7+nAUqqLvuAty8zDwMXA1uBe4AbMnNnRFxRdjABuDgidkbE7RR13heU218AfD4i7gA+DLwuMx/o8UuQpMqp3Iz3fGTmBmADwOTkpFfXSwLsAz5XmbkF2FK37dKa33+3yXkfAT7S3egkafAMyoz31yLiaQDlz/v7HI+kAdKs37d9wCVJvTQoifcmHv0K8wLgo32MRdKAsQ+4JKkKKldqEhEfpLiQ8oSI2AtcBqwHboiI1wJfAV7ZvwglDRr7gEuSqqByiXdmntdk13/taSCShop9wCVJ/Va5xFvSaNq4Y8oZaUnSUDPxltR39tmWJI0CE29JfTdTn+2qJt7O0EuS2mXiLanvBq3PtjP0kqS5GJR2gpKG2KD12XYlTEnSXDjjLanv1q5adtQMMrTfZ7vTpR8zPd6gzdBLkqrBxFtS3823z3anSz9me7zFC8eZapBkV3WGXpJUDSbekiphPn22O31x5myP14kZeknS6DHxljTwOl36MdvjuRKmJGkuTLwlDbxOl3608niuhClJapddTSQNvLWrljG+YOyobfMp/ej040mSBM54SxoCnS79sJREktQNJt6ShkKnSz8sJZEkdZqlJpIkSVIPOOMtSR3Q6QV8JEnDx8Rbkuap0wv4SJKGk6UmkjRPMy24I0nSNBNvSZqnTi/gI0kaTpaaSBpKvay5brbgznERLF232ZpvSRLgjLekITRdcz114CDJozXXG3dMdeX5Gi24A3AksyfP3y0RsToidkXE7ohY12D/6yLizoi4PSL+KSJOrdl3SXnerohY1dvIJamaTLwlDZ1e11yvWTHBVecsZ2LhOAGMRRxzzKDVfEfEGHAN8HLgVOC82sS6dF1mLs/M04C3A+8ozz0VOBd4DrAa+JPy8SRppFlqImkgzVRK0o+a69oFd5au29zz5++C04HdmXkvQERcD5wN3D19QGZ+u+b4JwJZ/n42cH1mPgR8KSJ2l4/36V4ELklV5Yy3pIEzWynJ4oXjDc9rtr3T+v38HTIB3Fdzf2+57SgR8fqI+CLFjPfvtHOuJI0aE29JA2e2UpJGNdfjC8ZYu2pZT+Lr9/N3yLH1Mo/OaD+6IfOazHwm8PvAW9o5NyIuiojtEbF9//798wpWkgaBpSaSBs5spSTTJR/9Wkmy38/fIXuBk2runwjsm+H464E/befczNwAbACYnJw8JjGXqmRJkxKyRvasP7OLkWiQmXhLGjjN2vfVlnLU1ly3otPtB9t9/gq6FTglIpYCUxQXS55fe0BEnJKZXyjvnglM/74JuC4i3gEsBk4BPtuTqCWpwiw1kTRwOl3K0ev2g4MgMw8DFwNbgXuAGzJzZ0RcERFnlYddHBE7I+J24I3ABeW5O4EbKC7E/Bjw+sw8csyTSNKIccZb0sDpdCnHTDXjAz5rPS+ZuQXYUrft0prff3eGc68EruxedJI0eEy8JTXUy5Uf56KTpRwu+S5J6gVLTSQdY9RKL4ak/Z8kqeJMvCUdo9crP/bbkLT/kyRVnKUmko4xaqUXQ9L+T5JUcSbeko7RSru+YTME7f+kvmun17U0iiw1kXQMSy8kSeo8Z7ylHqh6h5B6ll5IktR5Jt5Sl013CJm+WHG6QwhQ6UTW0gtJkjrLxFvqslFZnGXQZvUlSeo1E2+py0ahQ8igzupLktRLXlwpddkoLM4yl77fG3dMsXL9Npau28zK9duGdnEeSZKmmXhLXTYKHULandUftZUxJUkCE2+p69asmOCqc5YzsXCcACYWjnPVOcuHqgSj3Vn9UVsZU5IkGLAa74jYA/wncAQ4nJmT/Y1Ias2wdwhZu2rZUTXeMPOs/ijUvUuSVG+gEu/SizLz6/0OQtKj2u37PYorY0qSNIiJt6QKamdWv90ZckmShsGgJd4J/H1EJPDuzNzQ74CkQVC1HtuujClJGkWDlnivzMx9EfFDwMcj4t8y85bpnRFxEXARwMknn9yvGKVKqWqP7WGve5ckqd5AdTXJzH3lz/uBm4DT6/ZvyMzJzJxctGhRP0KUKqfVDiL21ZYkqbsGJvGOiCdGxJOnfwdeBtzV36ik6mulg4h9tSVJ6r5BKjX5YeCmiIAi7usy82P9DUlqrEo11a10EJlpVtxyEEmSOmNgEu/MvBf48X7HIc2mHzXVMyX6rXQQsa+2JEndNzClJtKg6PWqjLOVibSycma7K09KkqT2DcyMtzQoej173EqZyGwdROyrrUYiYjXwLmAMeE9mrq/b/0bg14HDwH7g1zLzy+W+I8Cd5aFfycyzeha4JFWUibfUYb1elbETib59tVUvIsaAa4CXAnuBWyNiU2beXXPYDmAyMx+MiN8C3g68qtx3MDNP62nQklRxJt5Sh/V69rhTib59tVXndGB3eX0NEXE9cDbwSOKdmZ+qOf4zwC/3NEJJGjDWeEsd1kpNdb359NBeu2oZ4wvGjtpmmYg6YAK4r+b+3nJbM68F/q7m/uMjYntEfCYi1nQjQEkaNM54S13QzuzxfLugWCaiLokG27LhgRG/DEwCL6zZfHK50vAzgG0RcWdmfrHuPFcbljRSTLylPutED+1BKBOpUm9ztWQvcFLN/ROBffUHRcRLgDcDL8zMh6a316w0fG9E3AysAI5KvDNzA7ABYHJysmFSL0nDxMRb6rN+9dDuZSLcj97mmrdbgVMiYikwBZwLnF97QESsAN4NrM7M+2u2Hw88mJkPRcQJwEqKCy8laaRZ4y31WT96aPd6ifhe9zbX/GXmYeBiYCtwD3BDZu6MiCsiYro14NXAk4C/jojbI2JTuf3ZwPaIuAP4FLC+rhuKJI0kZ7ylOejkbHE/emj3eol4V8YcTJm5BdhSt+3Smt9f0uS8fwGWdzc6SRo8Jt5SmzpdNtGPiyN7nQj3ure5JElVZOIttakbs8W9vjiy14mwK2NKkmTiLbVtGMom5pIIz6e8Zi6z+nZBkSQNGxNvqU3DUDbRbiLcifKaXvY2l6R+WrJuc8vH7ll/ZhcjUdWYeEttGpayiXYS4V5fjNnr55MkqRdMvKU2jeJKkc3KaKYOHGTpus0dfw+GoZxHkqR6Jt7SHAzCSpGd1Ky8BjiqDzh0phRkGMp5JEmq5wI6kma1dtUyxheMzXhMJxfEafR8g1jOI0lSLWe8Jc2qvrwmmxzXqVKQUSznkSQNPxNvaQh1oxVfbXnNyvXbul4KMmrlPJKk4WepiUbSxh1TrFy/jaXrNrNy/TY27pjqd0gdM92Kb6qcmZ6uv+7ka7QURJKk9pl4a+T0IjHtp5la8XXKmhUTXHXOciYWjhPAxMJxrjpnuTPUkiTNwFITjZxh7xHdq1Z8loJIktQeE2+NnGHvEW0rPkmd1M4qjJJmZqmJRk6zBHRYElPrryVJqqaWE++I+LmIMFHXwBv2xNT6azleS1I1tVNq8lHg/oj4S+B9mXlPl2KSumoUekRXof66Gy0N1TLHa0mqoHYS72cCvwr8CvB7EfFZ4FrgQ5n57W4EJ3VLFRLTYTbdOWb6ItZOLymvWTleS1IFtfxVZGbuyczLMnMp8FJgN/BO4KsR8f6IeFG3gpQ0WHrR0lDNOV5LUjXNqQYwM7dl5muAHwVuA14NfCIivhQRb4gIu6VII2zYO8cMEsdrSaqOOQ24EfFCiq8xfwE4BFwDbARWAX8A/BRwfodilLrOeuTOsqVhdTheS1J1tJx4R8TTgQvK2xLgZuAi4MbMfKg87JMR8WngrzobptQ91iN33tpVy456T2G4OsdUneO1JFVTOzPe9wL7gPcB12bml5octxP47Dzjknpm2Fey7IdR6BxTcY7XklRB7STePw98LDMfnumgzPx3wAt3NDCsR+4OO8f0VUfG64hYDbwLGAPek5nr6/a/Efh14DCwH/i1zPxyue8C4C3lof8jM/9ijq9FkoZGy4l3Zm7pZiBSv1SxHtmac81HJ8briBijqAd/KbAXuDUiNmXm3TWH7QAmM/PBiPgt4O3AqyLiqcBlwCSQwG3lud+cb1ySNMhc2Uwjr2orWU7XnE8dOEjyaM35xh1TfYlHI+t0YHdm3puZ3weuB86uPSAzP5WZD5Z3PwOcWP6+Cvh4Zj5QJtsfB1b3KG5JqiwTb428qi2x3qzm/E033MHSdZtZuX6bSbh6YQK4r+b+3nJbM68F/m6O50rSSLB/q0S16pGb1ZYfyQTsuqKeiQbbsuGBEb9MUVbywnbOjYiLKLqtcPLJJ88tSkkaIM54SxXTSm25q0CqB/YCJ9XcP5GiU8pRIuIlwJuBs2paFbZ0bmZuyMzJzJxctGhRxwKXpKoy8ZYqplHNeSN2XVGX3QqcEhFLI+KxwLnAptoDImIF8G6KpPv+ml1bgZdFxPERcTzwsnKbJI00S02kiqnvgX1cxCNlJrVcBVLdlJmHI+JiioR5jKIf+M6IuALYnpmbgKuBJwF/HREAX8nMszLzgYh4K0XyDnBFZj7Qh5chSZUyUIn3bD1lpWFRW3Nev7ImuAqkeqNsS7ilbtulNb+/ZIZzrwWu7V50kjR4BibxbrGnrDR0XAVSkqThMDCJNzU9ZQEiYrqnrIm3hl6Vuq5IkqS5GaSLK+0LK0mSpIE1SIn3rH1hI+KiiNgeEdv379/fo7AkSZKk2Q1S4j1rX1h7wkqSJKmqBinxnrWnrCRJklRVA3NxZbOesn0OSwKKln92HZEkSTMZmMQbGveUlfqtvs/21IGDXHLjnQAm35Ik6RGDVGoiVdLVW3cdtbgNwMFDR7h66663E4oeAAAV30lEQVQ+RSRJkqrIxFuap30HDra1XZIkjSYTb2meFi8cb2u7JEkaTSbe0jytXbWM8QVjR20bXzDG2lXL+hSRJEmqooG6uFKqoukLKO1qIkmSZmLiLXXAmhUTJtqSJGlGJt4aCrP10bbPtiRJ6jcTbw282fpo22dbkiRVgYm3Bl6zPtpvuuEO3vCh2zkugiOZx+y/euuupom3M+SSJKnTTLw18Jr1y55OtuuT7tnOc4ZckiR1g+0ENfDm2i+72XmuRClJkrrBGW8NvLWrlh01Q92KmfpsN5sJnzpwkKXrNlt6IknqmCXrNrd87J71Z3YxEvWCM94aeGtWTHDVOcuZWDhOAGMRDY8biyCAiYXjXHXO8qaJ80wz6MmjpScbd0zNP3hJkjQynPHWUKjto11fow3FDPdMyXatVmbQZ7s4U5IkqZ6Jt3qi3S4h8+kqMt+VJOvPb3xpZvOSFEmSpEZMvNV17XYJ6URXkfmuJFl7/sr125hqkGTP9aJOaVBExGrgXcAY8J7MXF+3/wXAHwE/BpybmR+u2XcEuLO8+5XMPKs3UUtSdVnjra5rt0tI1bqKrF21jPEFY0dtm+niTGkYRMQYcA3wcuBU4LyIOLXusK8AFwLXNXiIg5l5Wnkz6ZYknPFWDzQryejU9m6bb+lKN7jAj3rgdGB3Zt4LEBHXA2cDd08fkJl7yn0P9yNASRo0Jt7qusULx9sq1Wj3+F6Yb+lKJ7nAj3pkAriv5v5e4HltnP/4iNgOHAbWZ+bG+gMi4iLgIoCTTz55HqFK0mCw1ERAkcytXL+Npes2s3L9trZb5c10frulGpZ2zKxqpTgaWo36cja71riRkzNzEjgf+KOIeOYxD5a5ITMnM3Ny0aJFc41TkgaGM96a9wzqbOe3W6pRxdKOKqlaKY6G1l7gpJr7JwL7Wj05M/eVP++NiJuBFcAXOxmgJA0aE2/NOIPaSrLbyvntlmpUqbSjG+ZTo13FUhwNpVuBUyJiKTAFnEsxez2riDgeeDAzH4qIE4CVwNu7Fqna1s5qiZI6x1ITzXsG1RnY9kx/QzBV9ghvdyVMS3HUC5l5GLgY2ArcA9yQmTsj4oqIOAsgIn4qIvYCrwTeHRE7y9OfDWyPiDuAT1HUeN997LNI0mhxxlvznkFtdv5xESxdt9lSkTrz/YbBUhz1SmZuAbbUbbu05vdbKUpQ6s/7F2B51wOUpAFj4q2GS6S3M4PabIn1I1lch9WoZny+7fAGuZ1eJ74hGPZSHEmShpGlJmLNigmuOmc5EwvHCWBi4ThXnbO8rVUia88fi2ObIdR23ZhvqcV8z++3mdooSpKk4eWMt4DOLrG+tMlFO9Mzur24mLPK5vsNgyRJGkzOeKvjZpvRHfWLOef7DYMkSRpMznir42ab0e3WxZyDVKphjbYkSaPHGW913GwzunNph1e7MuZ3HzrMgrGj68gt1ZAkSVXnjLe6YqYZ3Xbb4dWvjHng4CEWHBcc/4QFHHjw0MB1NZEkSaPJxFt90U6pRaOLKQ89nDzhsY9hx6Uv60Z4kiRJHWfirYaq1Cd70C+mlCRJAmu81UDV+mTb91qSJA0DE28dY6Y+2f0wl4sxJUmSqsZSEx2jaqUd7V6MKUmSVEUm3jpGFftk2/dakiQNOktNdIxWSjtq+2qvXL+tb/XfkiRJg8IZbx1jttKO+r7a0xdf1p4rSZKko5l4q6GZSjtmuvjSxFuSJKkxS03UtqpdfClJkjQIBiLxjojLI2IqIm4vbz/b75hGmX21JUmS2jdIpSbvzMz/r99BjKralSyfMr6ABWPBoSP5yH77akuSJM1skBJv9Un9xZQHDh5iwXHB8U9YwIEHD9lXW5IkqQWDlHhfHBG/AmwH3pSZ3+x3QFVSOyPd6US40cWUhx5OnvDYx7Dj0pd15DkkSZKGXWVqvCPiExFxV4Pb2cCfAs8ETgO+Cvxhk8e4KCK2R8T2/fv39zD6/pqekZ46cJDk0fZ+neqt7cWUkiRJ81eZxDszX5KZz21w+2hmfi0zj2Tmw8CfA6c3eYwNmTmZmZOLFi3q7Qvoo5na+3VCLy6mdEEeqXoiYnVE7IqI3RGxrsH+F0TE5yLicET8Yt2+CyLiC+Xtgt5FLUnVVZnEeyYR8bSau68A7upXLFXU7RnpVlaynI9uz9hLal9EjAHXAC8HTgXOi4hT6w77CnAhcF3duU8FLgOeRzFRcllEHN/tmCWp6galxvvtEXEakMAe4Df7G07nzadGe/HCcaYaJNmdmpGebSXL+XJBHqmSTgd2Z+a9ABFxPXA2cPf0AZm5p9z3cN25q4CPZ+YD5f6PA6uBD3Y/bGl4LVm3ueVj96w/s4uRaK4GIvHOzNf0O4Zumu8S7GtXLTvqfOh8e7+ZVrKcL2vIpUqaAO6rub+XYgZ7ruf6V7SkkTcQpSbDbr412mtWTHDVOcuZWDhOABMLx7nqnOUDM1vsgjxSJUWDbdlg25zPHdUL4iWNroGY8R52rcz4zlaK0s0Z6W7rxYy9pLbtBU6quX8isK+Nc8+oO/fm+oMycwOwAWBycrLVpF6SBpYz3hUw24zvsF98OOgz9tKQuhU4JSKWRsRjgXOBTS2euxV4WUQcX15U+bJymySNNGe8K2C2Gd9RuPhwkGfspWGUmYcj4mKKhHkMuDYzd0bEFcD2zNwUET8F3AQcD/x8RPxBZj4nMx+IiLdSJO8AV0xfaClJo8zEuwJm6xrixYeS+iEztwBb6rZdWvP7rRRlJI3OvRa4tqsBStKAMfGuiJlmfLvdLlCSJEndZ433AOj2AjaSJEnqPme8B0C3F7CRJElS95l4DwgvPpQkSRpslppIkiRJPWDiLUmSJPWAibckSZLUA9Z4S5I0BJas29zvECTNwhlvSZIkqQdMvCVJkqQeMPGWJEmSesAa7x7ZuGOqrwvg9Pv5JUmSRp2Jdw9s3DHFJTfeycFDRwCYOnCQS268E6AnyW+/n1+SJEmWmnTMxh1TrFy/jaXrNrNy/TY27ph6ZN/VW3c9kvROO3joCFdv3dWT2Pr9/JIkSXLGuyNmm1Hed+Bgw/Oabe+0fj+/JEmSnPHuiNlmlBcvHG94XrPtndbv55ckSZKJd0fMNqO8dtUyxheMHbVvfMEYa1ct63psVXh+SZIkWWrSEYsXjjPVIPmenlGevoCxX11F+v38kiRJMvGes9r2fE8ZX8CCseDQkXxkf/2M8poVE31NdPv9/JIkSaPOxHsO6i+mPHDwEAuOC45/wgIOPHioIzPK8+27bd9uSZKkajHxnoNGF1Meejh5wmMfw45LXzbvx59v3237dkuSJFWPF1fOQbfb882377Z9uyVJkqrHxHsOut2eb76JvX27JUmSqsdSkzlYu2rZUaUc0Nn2fLN1SYGZa7hbOV+SZhMRq4F3AWPAezJzfd3+xwF/Cfwk8A3gVZm5JyKWAPcA01+zfSYzX9eruCXBknWb2zp+z/ozuxSJajnjPQdrVkxw1TnLmVg4TgATC8e56pzlHaufnq3v9nQN99SBgySP1nBPL1Nv325J8xURY8A1wMuBU4HzIuLUusNeC3wzM58FvBN4W82+L2bmaeXNpFuScMb7Ee12Aelme77Z+m7PVMNdG5ddTSTNw+nA7sy8FyAirgfOBu6uOeZs4PLy9w8DfxwR0csgJWmQmHhTzS4gMyX2rdRw27db0jxNAPfV3N8LPK/ZMZl5OCK+BfxguW9pROwAvg28JTP/scvxSlLlWWrC4HUB6fbFnZIENJq5zhaP+SpwcmauAN4IXBcRP3DME0RcFBHbI2L7/v375x2wJFWdiTeD1wXEGm5JPbAXOKnm/onAvmbHRMRjgKcAD2TmQ5n5DYDMvA34IvCj9U+QmRsyczIzJxctWtSFlyBJ1WKpCYPXBcQabkk9cCtwSkQsBaaAc4Hz647ZBFwAfBr4RWBbZmZELKJIwI9ExDOAU4B7exf68Gi3M4WkajPxpvvtAbvBGm5J3VTWbF8MbKVoJ3htZu6MiCuA7Zm5CXgv8P6I2A08QJGcA7wAuCIiDgNHgNdl5gO9fxWSVC0m3rQ2g9xu1xNJGnSZuQXYUrft0prfvwe8ssF5HwE+0vUAJWnAmHiXZppBrmLXE0mSJA0WE+8WzNY3ey6cQZckSRotJt5N1CbG9f2zps2164kz6JIkSaPHdoIN1C/J3sxcu54MWt9wSZIkzV9lEu+IeGVE7IyIhyNism7fJRGxOyJ2RcSqbsfSKDGuN5+uJ4PWN1ySJEnzV5nEG7gLOAe4pXZjRJxK0aLqOcBq4E8iYuzY0ztnpgQ4gImF41x1zvI5l4W48qQkSdLoqUyNd2beAxBxzArEZwPXZ+ZDwJfKfrGnUyzY0BXNFtSZWDjOP6978bwffxD7hkuSJGl+qjTj3cwEcF/N/b3ltq7p9pLsa1ZMcNU5y5lYON6RGXRJkiRVX09nvCPiE8CPNNj15sz8aLPTGmxreM1jRFwEXARw8sknzylG6M2S7K48KUmSNFp6mnhn5kvmcNpe4KSa+ycC+5o8/gZgA8Dk5ORMDUlmNd/E2D7dkiRpUCxZt7nlY/esP7OLkQy3ytR4z2ATcF1EvANYDJwCfLa/Ic3MPt2SpGbaSXAkDZfK1HhHxCsiYi/wfGBzRGwFyMydwA3A3cDHgNdn5sy9/vpsEPp0b9wxxcr121i6bjMr129j446pfockSZI01Coz452ZNwE3Ndl3JXBlbyOau6r36XZGXpIkqfcqM+M9TKrep3sQZuQlSZKGjYl3F3S7HeF8VX1GXpIkaRiZeHdB1ft0V31GXpIkaRhVpsZ72FS5T7crZ0qSJPWeifcI6sUCQZIkSTqaifeIqvKMvCRJqi4X25k7a7wlSZKkHnDGW5KkeXAlSkmtcsZbkiRJ6gETb0mSJKkHLDWRJDUUEauBdwFjwHsyc33d/scBfwn8JPAN4FWZuafcdwnwWuAI8DuZubWHoc+b5SNSZ3gh5tGc8ZYkHSMixoBrgJcDpwLnRcSpdYe9FvhmZj4LeCfwtvLcU4FzgecAq4E/KR9PkkaaM96SpEZOB3Zn5r0AEXE9cDZwd80xZwOXl79/GPjjiIhy+/WZ+RDwpYjYXT7ep3sUu6QBNAqz4ybekqRGJoD7au7vBZ7X7JjMPBwR3wJ+sNz+mbpzu7JwgCUhkmZTpYR+aBPv22677esR8eV+x9GCE4Cv9zuILvG1Da5hfn2D8tqe3ufnjwbbssVjWjmXiLgIuKi8+52I2FWzu2r/naoWD1QvJuOZmfHMrK144m3dCaLmcdt9f1oas4c28c7MRf2OoRURsT0zJ/sdRzf42gbXML++YX5tHbYXOKnm/onAvibH7I2IxwBPAR5o8VwycwOwodGTV+2/U9XigerFZDwzM56ZjUo8XlwpSWrkVuCUiFgaEY+luFhyU90xm4ALyt9/EdiWmVluPzciHhcRS4FTgM/2KG5JqqyhnfGWJM1dWbN9MbCVop3gtZm5MyKuALZn5ibgvcD7y4snH6BIzimPu4HiQszDwOsz80hfXogkVYiJd/81/Jp1SPjaBtcwv75hfm0dlZlbgC112y6t+f17wCubnHslcOU8nr5q/52qFg9ULybjmZnxzGwk4oniW0FJkiRJ3WSNtyRJktQDJt4VEhG/FxEZESf0O5ZOiYirI+LfIuLzEXFTRCzsd0zzFRGrI2JXROyOiHX9jqdTIuKkiPhURNwTETsj4nf7HVOnRcRYROyIiL/tdyxqXVXGxoh4azmW3R4Rfx8Ri/scT6XG14h4ZTl2PBwRfetOUbUxOiKujYj7I+KuCsRSuXE+Ih4fEZ+NiDvKmP6gAjF17bPCxLsiIuIk4KXAV/odS4d9HHhuZv4Y8O/AJX2OZ15aXEZ7UB0G3pSZzwZ+Gnj9EL22ab8L3NPvINS6io2NV2fmj2XmacDfApfOdkKXVW18vQs4B7ilXwFUdIx+H7C6zzFMq+I4/xDw4sz8ceA0YHVE/HSfY+raZ4WJd3W8E/hvNFhkYpBl5t9n5uHy7mco+vkOskeW0c7M7wPTy2gPvMz8amZ+rvz9PykGna6sNtgPEXEicCbwnn7HorZUZmzMzG/X3H0ifY6pauNrZt6TmbtmP7KrKjdGZ+YtFF1/+q6K43wWvlPeXVDe+vZvq9ufFSbeFRARZwFTmXlHv2Ppsl8D/q7fQcxTo2W0hyY5nRYRS4AVwL/2N5KO+iOKBO7hfgei1lRxbIyIKyPiPuDV9H/Gu9YwjK+dMBJjdCdUaZwvSztuB+4HPp6Z/Yypq58VthPskYj4BPAjDXa9GfjvwMt6G1HnzPTaMvOj5TFvpviK6wO9jK0LWloKe5BFxJOAjwD/d90M38CKiJ8D7s/M2yLijH7Ho0dVbWycbTzLzDcDb46IS4CLgcv6GU95TM/G11bi6bOhH6M7oWrjfNnn/7TyOoWbIuK5mdnzmvhefFaYePdIZr6k0faIWA4sBe6ICCi+KvxcRJyemf/RwxDnrNlrmxYRFwA/B/zXHPz+lS0thT2oImIBxWD8gcy8sd/xdNBK4KyI+Fng8cAPRMRfZeYv9zmukVe1sXG28azGdcBmupx4V218beP96ZehHqM7ocrjfGYeiIibKWri+3Exatc/Kyw16bPMvDMzfygzl2TmEopB4ycGJemeTUSsBn4fOCszH+x3PB3QyjLaAymK7Oa9wD2Z+Y5+x9NJmXlJZp5Y/hs7l2Jpc5PuCqvi2BgRp9TcPQv4t37FAkM5vnbC0I7RnVDFcT4iFk135ImIceAl9OnfVi8+K0y81W1/DDwZ+HjZguvP+h3QfJQXMk0vo30PcENm7uxvVB2zEngN8OLyv9Xt5V/9kgrrI+KuiPg8RQlMv1uxVWp8jYhXRMRe4PnA5ojY2usYqjhGR8QHgU8DyyJib0S8to/hVHGcfxrwqfLf1a0UNd5D2/LVlSslSZKkHnDGW5IkSeoBE29JkiSpB0y8JUmSpB4w8ZYkSZJ6wMRbkiRJ6gETb0mSJKkHTLwlSZKkHjDxliRJknrAxFtqQUQsLFcc+8u67Zsi4t8j4gn9ik2SdCzHbVWRibfUgsw8ALwWeE1ErAGIiF8FzgQuzMwH+xmfJOlojtuqIpeMl9oQEe8G1gCrgU8B787M3+9vVJKkZhy3VSUm3lIbIuJJwOeBxcBu4Ccz86H+RiVJasZxW1ViqYnUhsz8DvC3wOOA9zp4S1K1OW6rSpzxltoQEZPAp4E7gacDz8nM/+hvVJKkZhy3VSUm3lKLIuLxwOeAe4FfAu4A7snMs/oamCSpIcdtVY2lJlLr/gfwI8BvlFfDXwCcGREX9jUqSVIzjtuqFGe8pRZExErgFuA1mXldzfargd8AnpuZe/sVnyTpaI7bqiITb0mSJKkHLDWRJEmSesDEW5IkSeoBE29JkiSpB0y8JUmSpB4w8ZYkSZJ6wMRbkiRJ6gETb0mSJKkHTLwlSZKkHjDxliRJknrg/wf9KPPHSPU1DgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#create figure explicitly\n",
    "fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(12,5))\n",
    "\n",
    "### FIRST FIGURE\n",
    "\n",
    "#generate bunch of random but correlated data\n",
    "x = np.linspace(-5,5,70) #create x values\n",
    "y = 2*x+np.random.normal(0,2,size=x.shape[0])\n",
    "\n",
    "axs[0].plot(x,y,'o', label='Random data')\n",
    "\n",
    "axs[0].set_title('Scatterplot', fontsize=20)\n",
    "\n",
    "\n",
    "### SECOND FIGURE\n",
    "\n",
    "#generate bunch of random normal data\n",
    "data = np.random.normal(size=10000)\n",
    "\n",
    "axs[1].hist(data, bins=25, density=True, label='Random normal data')\n",
    "\n",
    "axs[1].set_title('Histogram', fontsize=20)\n",
    "\n",
    "\n",
    "# plot labels for each plot\n",
    "for ax in axs:\n",
    "    ax.set_xlabel('x', fontsize=15)\n",
    "    ax.set_ylabel('y', fontsize=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Images**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2d numpy arrays can be seen as images, where each entry is the color value of a single pixel in the image. We can show images encoded in this way with an appropriate plotting function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f1712edeeb8>"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot a gaussian noise image\n",
    "fig, ax = plt.subplots(figsize=(6,6))\n",
    "\n",
    "data = np.random.normal(0,1,size=(50,50))\n",
    "\n",
    "img = ax.imshow(data, cmap='Greys')\n",
    "\n",
    "plt.colorbar(img)"
   ]
  }
 ],
 "metadata": {
  "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}