tutorial_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial: NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "__author__ = \"Christopher Potts, Will Monroe, and Lucy Li\"\n",
    "__version__ = \"CS224u, Stanford, Spring 2021\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "\n",
    "1. [Motivation](#Motivation)\n",
    "1. [Vectors](#Vectors)\n",
    "  1. [Vector Initialization](#Vector-Initialization)\n",
    "  1. [Vector indexing](#Vector-indexing)\n",
    "  1. [Vector assignment](#Vector-assignment)\n",
    "  1. [Vectorized operations](#Vectorized-operations)\n",
    "  1. [Comparison with Python lists](#Comparison-with-Python-lists)\n",
    "1. [Matrices](#Matrices)\n",
    "  1. [Matrix initialization](#Matrix-initialization)\n",
    "  1. [Matrix indexing](#Matrix-indexing)\n",
    "  1. [Matrix assignment](#Matrix-assignment)\n",
    "  1. [Matrix reshaping](#Matrix-reshaping)\n",
    "  1. [Numeric operations](#Numeric-operations)\n",
    "1. [Practical example: a shallow neural network](#Practical-example:-a-shallow-neural-network)\n",
    "1. [Going beyond NumPy alone](#Going-beyond-NumPy-alone)\n",
    "  1. [Pandas](#Pandas)\n",
    "  1. [Scikit-learn](#Scikit-learn)\n",
    "  1. [SciPy](#SciPy)\n",
    "  1. [Matplotlib](#Matplotlib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Motivation\n",
    "\n",
    "Why should we care about NumPy? \n",
    "\n",
    "- It allows you to perform tons of operations on vectors and matrices. \n",
    "- It makes things run faster than naive for-loop implementations (a.k.a. vectorization). \n",
    "- We use it in our class (see files prefixed with `np_` in your `cs224u` directory). \n",
    "- It's used in a ton in machine learning / AI. \n",
    "- Its arrays are often inputs into other important Python packages' functions. \n",
    "\n",
    "In Jupyter notebooks, NumPy documentation is two clicks away: Help -> NumPy reference. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vector Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert list to numpy array\n",
    "np.array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 1.0, 1.0, 1.0, 1.0]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert numpy array to list\n",
    "np.ones(5).tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# one float => all floats\n",
    "np.array([1.0,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as above\n",
    "np.array([1,2,3,4,5], dtype='float')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# spaced values in interval\n",
    "np.array([x for x in range(20) if x % 2 == 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as above\n",
    "np.arange(0,20,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.20907096, 0.36931203, 0.44534147, 0.6545148 , 0.55729317,\n",
       "       0.23846956, 0.0998131 , 0.01546743, 0.91981562, 0.43352004])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# random floats in [0, 1)\n",
    "np.random.random(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11,  9, 12,  5, 12,  7, 10, 13, 14,  9])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# random integers\n",
    "np.random.randint(5, 15, size=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vector indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([10,20,30,40,50])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slice\n",
    "x[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30, 40, 50])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0:1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# last value\n",
    "x[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([50])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# last value as array\n",
    "x[[-1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 40, 50])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# last 3 values\n",
    "x[-3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 30, 50])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pick indices\n",
    "x[[0,2,4]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vector assignment\n",
    "\n",
    "Be careful when assigning arrays to new variables! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#x2 = x # try this line instead\n",
    "x2 = x.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30, 40, 50])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[0] = 10\n",
    "\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10, 40, 50])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[[1,2]] = 10\n",
    "\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10,  0,  1])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[[3,4]] = [0, 1]\n",
    "\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30, 40, 50])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if the original vector changed\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectorized operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.30258509, 2.99573227, 3.40119738, 3.68887945, 3.91202301])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.20264658e+04, 4.85165195e+08, 1.06864746e+13, 2.35385267e+17,\n",
       "       5.18470553e+21])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 20,  40,  60,  80, 100])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + x  # Try also with *, -, /, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 21, 31, 41, 51])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison with Python lists\n",
    "\n",
    "Vectorizing your mathematical expressions can lead to __huge__ performance gains. The following example is meant to give you a sense for this. It compares applying `np.log` to each element of a list with 10 million values with the same operation done on a vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# log every value as list, one by one\n",
    "def listlog(vals):\n",
    "    return [np.log(y) for y in vals]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.13948279, 1.71442668, 1.2142152 , ..., 1.52286464, 1.83729564,\n",
       "       1.71988707])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get random vector\n",
    "samp = np.random.random_sample(int(1e7))+1\n",
    "samp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 97.8 ms, sys: 16.5 ms, total: 114 ms\n",
      "Wall time: 114 ms\n"
     ]
    }
   ],
   "source": [
    "%time _ = np.log(samp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 11 s, sys: 135 ms, total: 11.1 s\n",
      "Wall time: 11.2 s\n"
     ]
    }
   ],
   "source": [
    "%time _ = listlog(samp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrices\n",
    "\n",
    "The matrix is the core object of machine learning implementations. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([[1,2,3], [4,5,6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [4., 5., 6.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([[1,2,3], [4,5,6]], dtype='float')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag([1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix indexing"
   ]
  },
  {
   "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": [
    "X = np.array([[1,2,3], [4,5,6]])\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get row\n",
    "X[0, : ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get column\n",
    "X[ : , 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [4, 6]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get multiple columns\n",
    "X[ : , [0,2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# X2 = X # try this line instead\n",
    "X2 = X.copy()\n",
    "\n",
    "X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[20,  2,  3],\n",
       "       [ 4,  5,  6]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X2[0,0] = 20\n",
    "\n",
    "X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 3, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X2[0] = 3\n",
    "\n",
    "X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 3, 5],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X2[: , -1] = [5, 6]\n",
    "\n",
    "X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if original matrix changed\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix reshaping"
   ]
  },
  {
   "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": [
    "z = np.arange(1, 7)\n",
    "\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6,)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z = z.reshape(2,3)\n",
    "\n",
    "Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z.reshape(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same as above\n",
    "Z.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# transpose\n",
    "Z.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numeric operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [4., 5., 6.]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array(range(1,7), dtype='float').reshape(2,3)\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  4.,  9.],\n",
       "       [ 4., 10., 18.]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# not the same as A.dot(B)\n",
    "A * B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 4., 6.],\n",
       "       [5., 7., 9.]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 1. , 1. ],\n",
       "       [4. , 2.5, 2. ]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A / B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14., 32.])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matrix multiplication\n",
    "A.dot(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14., 32.])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.dot(A.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14., 32.],\n",
       "       [32., 77.]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.dot(A.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [2, 4, 6],\n",
       "       [3, 6, 9]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# outer product\n",
    "# multiplying each element of first vector by each element of the second\n",
    "np.outer(B, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practical example: a shallow neural network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following is a practical example of numerical operations on NumPy matrices. \n",
    "\n",
    "In our class, we have a shallow neural network implemented in `np_shallow_neural_network.py`. See how the forward and backward passes use no for loops, and instead takes advantage of NumPy's ability to vectorize manipulations of data. \n",
    "\n",
    "```python\n",
    "def forward_propagation(self, x):\n",
    "    h = self.hidden_activation(x.dot(self.W_xh) + self.b_xh)\n",
    "    y = softmax(h.dot(self.W_hy) + self.b_hy)\n",
    "    return h, y\n",
    "\n",
    "def backward_propagation(self, h, predictions, x, labels):\n",
    "    y_err = predictions.copy()\n",
    "    y_err[np.argmax(labels)] -= 1\n",
    "    d_b_hy = y_err\n",
    "    h_err = y_err.dot(self.W_hy.T) * self.d_hidden_activation(h)\n",
    "    d_W_hy = np.outer(h, y_err)\n",
    "    d_W_xh = np.outer(x, h_err)\n",
    "    d_b_xh = h_err\n",
    "    return d_W_hy, d_b_hy, d_W_xh, d_b_xh\n",
    "```\n",
    "\n",
    "The forward pass essentially computes the following: \n",
    "    $$h = f(xW_{xh} + b_{xh})$$\n",
    "    $$y = \\text{softmax}(hW_{hy} + b_{hy}),$$\n",
    "where $f$ is `self.hidden_activation`. \n",
    "\n",
    "The backward pass propagates error by computing local gradients and chaining them. Feel free to learn more about backprop [here](http:https://cs231n.github.io/optimization-2/), though it is not necessary for our class. Also look at this [neural networks case study](http:https://cs231n.github.io/neural-networks-case-study/) to see another example of how NumPy can be used to implement forward and backward passes of a simple neural network. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Going beyond NumPy alone\n",
    "\n",
    "These are examples of how NumPy can be used with other Python packages. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas\n",
    "We can convert numpy matrices to Pandas dataframes. In the following example, this is useful because it allows us to label each row. You may have noticed this being done in our first unit on distributed representations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>gnarly</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wicked</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>awesome</th>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lame</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>terrible</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            0    1    2    3    4    5\n",
       "gnarly    1.0  0.0  1.0  0.0  0.0  0.0\n",
       "wicked    0.0  1.0  0.0  1.0  0.0  0.0\n",
       "awesome   1.0  1.0  1.0  1.0  0.0  0.0\n",
       "lame      0.0  0.0  0.0  0.0  1.0  1.0\n",
       "terrible  0.0  0.0  0.0  0.0  0.0  1.0"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_df = pd.DataFrame(\n",
    "    np.array([\n",
    "        [1,0,1,0,0,0],\n",
    "        [0,1,0,1,0,0],\n",
    "        [1,1,1,1,0,0],\n",
    "        [0,0,0,0,1,1],\n",
    "        [0,0,0,0,0,1]], dtype='float64'),\n",
    "    index=['gnarly', 'wicked', 'awesome', 'lame', 'terrible'])\n",
    "count_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn\n",
    "\n",
    "In `sklearn`, NumPy matrices are the most common input and output and thus a key to how the library's numerous methods can work together. Many of the cs224u's model built by Chris operate just like `sklearn` ones, such as the classifiers we used for our sentiment analysis unit. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn import datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "Dimensions of X: (150, 4)\n",
      "<class 'numpy.ndarray'>\n",
      "Dimensions of y: (150,)\n"
     ]
    }
   ],
   "source": [
    "iris = datasets.load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "print(type(X))\n",
    "print(\"Dimensions of X:\", X.shape)\n",
    "print(type(y))\n",
    "print(\"Dimensions of y:\", y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_iris_train: <class 'numpy.ndarray'>\n",
      "y_iris_train: <class 'numpy.ndarray'>\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "      setosa       1.00      1.00      1.00        11\n",
      "  versicolor       1.00      0.74      0.85        19\n",
      "   virginica       0.75      1.00      0.86        15\n",
      "\n",
      "    accuracy                           0.89        45\n",
      "   macro avg       0.92      0.91      0.90        45\n",
      "weighted avg       0.92      0.89      0.89        45\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# split data into train/test\n",
    "X_iris_train, X_iris_test, y_iris_train, y_iris_test = train_test_split(\n",
    "    X, y, train_size=0.7, test_size=0.3)\n",
    "print(\"X_iris_train:\", type(X_iris_train))\n",
    "print(\"y_iris_train:\", type(y_iris_train))\n",
    "print()\n",
    "\n",
    "# start up model\n",
    "maxent = LogisticRegression(\n",
    "    fit_intercept=True,\n",
    "    solver='liblinear',\n",
    "    multi_class='auto')\n",
    "\n",
    "# train on train set\n",
    "maxent.fit(X_iris_train, y_iris_train)\n",
    "\n",
    "# predict on test set\n",
    "iris_predictions = maxent.predict(X_iris_test)\n",
    "fnames_iris = iris['feature_names']\n",
    "tnames_iris = iris['target_names']\n",
    "\n",
    "# how well did our model do?\n",
    "print(classification_report(y_iris_test, iris_predictions, target_names=tnames_iris))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SciPy\n",
    "\n",
    "SciPy contains what may seem like an endless treasure trove of operations for linear algebra, optimization, and more.  It is built so that everything can work with NumPy arrays. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.spatial.distance import cosine\n",
    "from scipy.stats import pearsonr\n",
    "from scipy import linalg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.11932101822769925"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# cosine distance\n",
    "a = np.random.random(10)\n",
    "b = np.random.random(10)\n",
    "cosine(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.10357764286724046, 0.7758390819294883)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pearson correlation (coeff, p-value)\n",
    "pearsonr(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.48,  0.36,  0.88],\n",
       "       [ 0.56,  0.08, -0.36],\n",
       "       [ 0.16, -0.12,  0.04]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# inverse of matrix\n",
    "A = np.array([[1,3,5],[2,5,1],[2,3,8]])\n",
    "linalg.inv(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn more about how NumPy can be combined with SciPy and Scikit-learn for machine learning, check out this [notebook tutorial](https://github.com/cgpotts/csli-summer/blob/master/advanced_python/intro_to_python_ml.ipynb) by Chris Potts and Will Monroe. (You may notice that over half of this current notebook is modified from theirs.) Their tutorial also has some interesting exercises in it! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAEICAYAAABCnX+uAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAo70lEQVR4nO3deZxU1Z338c+v95Xeu6FpmmZTFlGEDhrcl4QsGodkkjH6GhdQYmai5pnMM3kmGqMxJiajySRjZhIyGs3i8iQZJxp3H5MRQQQMBBAUAWlotm4auul9Pc8fp3pl66aqu7qqvu/Xq15Vt+6te391ha+HU+eea845REQkcsWFuwAREQmOglxEJMIpyEVEIpyCXEQkwinIRUQinIJcRCTCKcgl5pjZIjPbbWYNZnb2CB73WjN7eaSOJ7HDNI5chouZnQ98D5gFdAJbgC8759aEua7twD84534/jMcoAz4AEp1zHcN1HBGAhHAXINHJzMYAfwC+CPxfIAm4AGgNZ10BE4F3wl2ESKioa0WGy2kAzrknnHOdzrlm59zLzrkNAGYWZ2Z3mlmFmVWZ2S/MLCuwrszMnJndGOgCOWxmt5jZh8xsg5nVmtlDfQ9mZovNbEtg25fMbOLAgsws2cwagHjgL4GWOYFjTe2z3aNm9q3A64vNrNLMvhKoc5+Z3dhn21QzezDwPerM7A0zSwVeD2xSG+jC+bCZ3WBmb/T57AIzWxP43BozW9Bn3Z/M7F4zW2Fm9Wb2spnlB9almNmvzKwmcC7WmFlRcP+5JJIpyGW4bAU6zewxM/u4meUMWH9D4HEJMBnIAB4asM05wDTgb4B/Be4ALsd31XzOzC4CMLO/Ar4GfBooAJYDTwwsyDnX6pzLCCye5ZybMsjvMhbIAsYDS4Af9/k+DwDzgAVALvBPQBdwYWB9tnMuwzn3Zt8dmlku8BzwIyAP+D7wnJnl9dnsGuBGoBD/L5p/DLx/faCeCYHP3gI0D/K7SBRSkMuwcM4dAc4HHPAzoNrMnunTcrwW+L5zbodzrgH4Z+BqM+vb3Xevc67FOfcy0Ag84Zyrcs7twYd19w+VXwC+45zbEuiP/jYw51it8lPUDnzTOdfunHseaABON7M4YDFwu3NuT+BfHiudc4PpPvok8L5z7pfOuQ7n3BPAu8CVfbb5uXNuq3OuGd89NadPPXnA1MAx3w6cb4lRCnIZNoFgvcE5VwKcARTjW9YEXlf02bwC/5tN3y6CA31eNx9jubt1PRH4YaCboRY4BBi+BR0KNQN+sGwKHDsfSAG2n8I+B35/Ast9a95/jGMC/BJ4CXjSzPaa2ffMLPEUapAooSCXEeGcexd4FB/oAHvxAdytFOigf1gP1m7gC8657D6PVOfcykF+vglI67M8dpCfOwi0AMfqojnZcLCB3x/8OdhzsoMG/mVwj3NuJr5L5wrgupOXK9FKQS7DwsymB34gLAksTwA+D6wKbPIE8L/MbJKZZeC7Q546xaF6PwH+2cxmBY6VZWafHcLn1wPXmFm8mX0MuGgwH3LOdQGPAN83s+LA5z9sZslANb6vfPJxPv48cJqZXWNmCWb2N8BM/EifEzKzS8xstpnFA0fwXS2dg6lZopOCXIZLPf7HyrfMrBEf4JuArwTWP4LvIngdP966Bbj1VA7knHsa+C6+q+FI4DgfH8Iubsf3Tdfi++7/ewif/UdgI7AG36XzXSDOOdcE3AesCHT5nDug5hp8S/orQA3+R9IrnHMHB3HMscBv8SG+Bfgf4FdDqFmijC4IEhGJcGqRi4hEOAW5iEiEU5CLiEQ4BbmISIQLy6RZ+fn5rqysLByHFhGJWG+//fZB51zBwPfDEuRlZWWsXbs2HIcWEYlYZjbwamBAXSsiIhFPQS4iEuFCEuRm9khgruZNodifiIgMXqha5I8CHwvRvkREZAhCEuTOudfx80yIiMgIG7E+cjNbamZrzWxtdXX1SB1WRCTqjViQO+eWOefKnXPlBQVHDYMUEZFTFJZx5CIisaKjs4sPDjby7v563ttfz9XzJ1CSk3byDw6BglxEJAScc+w/0tIT2O/tr+fd/fVsr2qgrbMLgPg4Y+7E7NEZ5Gb2BHAxkG9mlcA3nHMPh2LfIiKjTV1TO1urfFhvPVDfE951ze0924wdk8LpYzO5cFo+p4/N5PSxmUwtzCA5IT7k9YQkyJ1znw/FfkRERpP6lnber2pg24EGth6oZ2tVA1v317P/SEvPNhnJCZxWlMEnZo9jeiCwp4/NJDstacTqVNeKiMS8uuZ2tlU18P6Bet6vavCPA/Xsq+sN7KSEOKYVZrBgSh6njc3k9KJMphVlMD47FTMLY/UKchGJIYca29he3cC2Kt/C7n4+cKS1Z5uUxDimFmZw7uQ8phZmcFpRJtMKM5iQm0Z8XHgD+3gU5CISVbq6HPuOtLCtqqHnsb2qgW3VDRxqbOvZLjUxnqmFGZw3NZ9phZmcVpTBtMJMxuekjtrAPh4FuYhEpMbWDnZUN7LjYAPbqxvZUe2fPzjYQEt7V8922WmJTC3I4KMzi5hamMGUggymFvoukbgIC+zjUZCLyKjV2eXYW9vMjoPdQd3gw7u6sd8PjnEGJTlpTClIZ8GUPCYXpPcEdl56Utj7sIebglxEwso5R3VDKzsPNvHBwQZ2HGzkg+pGPjjYSEVNU88YbIDMlASmFGSwYGoeUwoymJyfzpTCDCbmpQ3LsL5IoSAXkWHnnONgQxsVNT6gd9Y0srOmiZ2BsG5o7ejZNjHemJiXzqT8dC6dXsikfP96ckEG+RnR37o+FQpyEQmJto4u9tY2s+tQExWHmth9qIldNb2v+4Z1fJxRkpNKWV46HyrLpSwvjUmBFnZxduT92BhuCnIRGRTnHHXN7T6oa5rY1R3WgeV9dc10ud7tkxLiKM1NozQ3jXMm+bCemJ/OxNw0JuSmkRivG5SFioJcRHq0d3axr7Yl0KpuPCqs61s6+m2fn5FMaW4qHyrLoTR3PKV56T3hXZiZHDWjQkY7BblIDOnschw40kLl4WYqDzf1PO8+1ExlbRN7a1vo7NOsToqPoyQnldK8NOaW5vSEdGleGhNy0khPVoSMBvqvIBJFWto72VfXwt7aZvYcbqYy8Lyntok9tc3sq22ho2//B1CYmUxJTipnT8jhqrN6g7o0N42iMSnqr44ACnKRCNHZ5aiqb2FvbQv76prZW9vc57V/PtjQ1u8zZlCUmcL4nFTmluYw/sxUxuekMiEnjZKcVIqzU0lJjN1he9FCQS4yCnR1OQ42trK/roV9dS3sr2thb51vQe+tbfbvHenf7QGQnhRPcXYq47JTmVU8hnFZPqjHZ/vH2KwUkhL0o2K0U5CLDCPnHEeaO6iqb+HAkVYOHGnhQH0LVUdaqar3gb2/roWq+tajujwS441xWamMy0ph/qRcirNTGJeVSnF2ig/vrFTGpCRoXLUoyEVOhXOO+tYOqo74UD7QJ6ir6lupOtK73NrRddTnM5MTKBiTzNgxKZw7JY+xY1IYm5XSE9xjs1LITUvSqA8ZFAW5SB8t7Z0cbGjlYEMbB+tbA6/9cnVDK9WBlvSBI600t3ce9fmM5AQKM5MpHJPM2aXZFI1JCSynUJSZ7JfHJJOWpL96Ejr60yRRrbtro6axlUONbdQ0tvlgrm/rE9K9wV3f2nHM/XS3oPMzkpldks3lfUK5MDOFojE+rDM0HE/CQH/qJGI452hq6+RwUxu1Te09z7VNbRxuau8J6kONrdQ0+NeHG9uO6nvulp2WSH5GMvkZScwqHkN+RjIFmX45PyOZvIze1xrZIaOZglzCoq2jqyeA+z7XNgcCujHw3Ny7vq6pvd9MeANlpiSQl55EbnoSJTlpzJmQTW5gOS8jibz0ZHLTfTDnpidpNIdEDQW5DFlrRyf1LR00tHRQ39JBfWt7n+V2Glq73+8IvB9YH1iubWqjse3o/uVuSfFxZKclkpOWRHZaIpPy05mblkR2WhI5aYlkpyUGXicFXieSnapgltilII8hnV0uEKa9YdvQ0sGRAcv1Le19QnhgUHecsFXcLTkhjsyUBDJTEslITiAzJYGJGWlkJHcHbyLZ6T6Yc9KSyEpNJCewnJoYryF1IkMQkiA3s48BPwTigf90zt0fiv3GCuccnV2O9k5HW2cXrR2dtLR10dze6R9tnbS0+8fR7/Xfrqmtg6a27te9y42tHSdsBXeLM/qFb2ZKAoWZKUzO968zUhIY0299/227l9U6Fhk5QQe5mcUDPwY+AlQCa8zsGefc5mD3PVBDawfNbZ04HM5Bl3N0OX9VHPRZdg7nurfpft8vuz7L/mP+ub2zywdpR1fgdVfgtetd7uyivaP/cu/2LrB+wHL3I/C5Y36mswt37N/jTirO/E1kU5PiSUmMJz0pgdSkeNKS4slOSyQtKYH05HhSE/uG7fEDOC1JrWGRSBOKFvl8YJtzbgeAmT0JXAWEPMjvf2ELv1q1K9S7HbL4OCMx3kiMjyMpPo7E+DgSE3qXkxIC78Wbb532bOPf61kOfC65z/qEOCMlMZ7URB/MqUlxPcupSfGkJPSGdmpiPInxpuAViXGhCPLxwO4+y5XAOQM3MrOlwFKA0tLSUzrQFWcWc3pRJmZGnBlxBnFmEHjuXjYjsE3v+9BnOc6vN3q37w7WpBOEcvc2mg1ORIakoxXq9/tHwemQmh3S3YciyI+Vakd1FDjnlgHLAMrLy0+pI+HcyXmcOznvVD4qIhJ6XZ3QeBDq9waCeh8c2eefu5fr90FTTe9nrv0dTLs8pGWEIsgrgQl9lkuAvSHYr4hI+HS0BoJ5L9TtgSN7epe7A7thP3QNvBrYIKMIMsdC1gSYMB8yx/nlzGIYPzfkpYYiyNcA08xsErAHuBq4JgT7FREZHm1NgTDe44O557nP68bqoz+XlAljxvlgnnSBfx5THAjqcX5deiHEj+zI7qCP5pzrMLMvAS/hhx8+4px7J+jKRERORWd7byDX7YG63b2vj1T65+ZDR38uJRvGjIes8VB8tn89pjjwGO+DOmXMiH+dwQjJ/zacc88Dz4diXyIiJ9RSB7W7oa7Sh3S/50rf0nYDLlpLyYIxJT6kx5f75zElvSE9ZhwkpYfn+4SAruwUkdHDOWio8sFcWxEI7N29z3WV0Hqk/2fikwIt6RKYfLF/7m5ZZ03wr5MzwvJ1RoqCXERGTndQ1+4KBHVF4HXgUVcJHS39P5OSDdkTIGcSlF3ggzp7gg/prBLfJx0X21cSK8hFJLTam+HwTjj0ARz+wL8+vBMOB0K7o7n/9mn5PpiLzoDTPw5ZpZBd2hvWo7RfejRRkIvI0Djnx0X3Deru14c+8EPy+krKhNwyyJ8G0z4SCOmJkDPRB3WUd3uMBAW5iByts8P3SR8V1Dv9clt9/+0ziyGnDKZe5rtAcif55ZxJkJYLmkZiWCnIRWJVR1sgpLdDzXY4tMM/Du/0Id73Qpf4ZN+CzpkEExcEgro7rCdCYmqYvoSAglwkunV1+lA+uC0Q2NsCj+3+/b7D9FKyIXeyH0N9xqf7t6wzi2P+B8XRTEEuEg1a6uDg+3Bwq3+ueT8Q3jugs7V3u6RMyJsMJeVw5t9A3hTIneKf03LDV78ERUEuEimc8xe7VL8XCO33fHBXb+3/A2Ncgm9Nd/+4mDfVP/KnQXqB+qujkIJcZLTp6vQ/Lla/Gwjr93vDu++PjMljIP80mHIpFJwG+af75ZyJEJ8YvvplxCnIRcKlq9P/sFi1Baq3QNW7gfB+v393SOY4H9BzPu+fux+ZY9W6FkBBLjIymg7BgXcCj03+uWpL/4tjskqhcDpMuQQKZvgbEOSfpgti5KQU5CKh1NnhR4Uc2NQb2Afe8bPvdUvL81cxli+GopmB0D4NkjPDV7dENAW5yKlqrIEDG/u3tKve7e0WiUv0reqy86Folg/vojMgo1BdIhJSCnKRk+nq8q3s/RsCj0BLu+9IkYwiH9LnfCEQ2LN8t0hCUvjqlpihIBfpq6vLX4q+d13vY99foK3Br49PgoLpfqRI0SwYewYUzoKMgvDWLTFNQS6xyzk/amRgaHfPd52QAmNnw1mfh+I5MG6O7yrR0D4ZZRTkEjvq90PlGtjzdiC410NLrV8Xn+S7RGb/tb9Evfhs3/JWaEsEUJBLdOpo9a3ryjWBx1o/twj4Kx8LZ8LMq3pDu3Cm+rMlYinIJTrU7oLdq31gV67xP0p2tvl1WRP83CLnfhFKPgRjz4TElPDWKxJCCnKJPN192zvfgIoV/rm7tZ2QCuPn9ob2+HJ/Y12RKBZUkJvZZ4G7gRnAfOfc2lAUJdKPc34Wv+7Q3rkCjlT6dWl5fpz2glthwjl+JIn6tSXGBNsi3wR8GvhpCGoR8bqDe+dyH9o734D6vX5dWr4P7rIv++eC6bq4RmJeUEHunNsCYPqLJMFwzl9ws/ON3kf3xTbphYHgPs/fQT3/NAW3yADqI5eR55yf4W/n8t7ukoYDfl1GUSC4z4eJ5/s5tBXcIid00iA3s1eBscdYdYdz7veDPZCZLQWWApSWlg66QIkSrfXw/svw7nPwwXJorPLvZ46DSRfCxECLO2+KgltkiE4a5M65y0NxIOfcMmAZQHl5uQvFPmWUaz4M770Am5+B7a/5yaTSC2DyJb2t7tzJCm6RIKlrRUKrocq3urc8Ax+87u/EPmY8lN8IMz4FpedCXHy4qxSJKsEOP1wE/BtQADxnZuudcwtDUplEjro9sOVZH9673vR3Zs+ZBB/+e5hxlR/XrVa3yLAJdtTK08DTIapFIsmhHb7LZMuzsCdw+UDBDLjwf8OMK/28JQpvkRGhrhUZvKp3fat78zP+hgrgZwS89Ot+3pL8aWEtTyRWKcjl+JzzE09tCbS8D2717084Bz56n29550wMb40ioiCXAbq6/KRTW57xj9pdYHF+hMn8pTD9Cs1dIjLKKMjF3zB410rfZfLuH6B+n7/f5OSLfZ/36Z+E9LxwVykix6Egj1UdbfDB/8Dm38N7z0NTjZ85cOplvr/7tIWQkhXuKkVkEBTksaS9Gba96vu733sRWusgKdOH9owrYdpHICk93FWKyBApyKNdZ4e/NH7Dk/D+K9DeBCnZMOMKf4HO5It1kwWRCKcgj1Z1lfD2Y7Dul77PO70Azrrah3fZ+ZqzWySKKMijSVcXfPAnWPOw7/d2zneXfOIB332i8BaJSgryaNDeDOt+Bav+Aw5t9zdfOO/LMO8GjfMWiQEK8kjWcgTWPgxv/hgaq/39KT/9Mz/qJCE53NWJyAhRkEeixhp46z9g9TJoqYMpl8IFX/Fzemt+E5GYoyCPJHV74M2H4O1H/eiTGVfC+f/gZxcUkZilII8ENdthxb/C+if8FLFnfs73gRdOD3dlIjIKKMhHs/2b4I3vwztP+0vm510PC27TD5gi0o+CfDTavRqWPwhbX/RXXi64Fc79e8gsCndlIjIKKchHk6ZD8N9f9AGemguX3Anzb4LUnHBXJiKjmIJ8tKh+D564Gmp3w+X3wPybNe+JiAyKgnw0eO9F+N1NkJgKNzwHpeeEuyIRiSBx4S4gpjkHb/zAt8TzJsPSPyrERWTI1CIPl/ZmeOZW2PgbOOMz8KmHICkt3FWJSARSkIdD3R548hp/P8zL7vIX9eiKTBE5RUEFuZn9C3Al0AZsB250ztWGoK7otXs1PHmtvzLz80/A6R8Pd0UiEuGC7SN/BTjDOXcmsBX45+BLimLrfg2PftKPRrnpVYW4iIREUEHunHvZOdcRWFwFlARfUhTq7IAXvwa//zso/TDc/BoUzgh3VSISJULZR74YeCqE+4sOzYfht4th+2twzi3w0fsgXj9NiEjonDRRzOxVYOwxVt3hnPt9YJs7gA7g1yfYz1JgKUBpaekpFRtxqt+DJz4PtbvgU/8Gc68Ld0UiEoVOGuTOuctPtN7MrgeuAC5zzrkT7GcZsAygvLz8uNtFja0vw++W+Bs83PAHKD033BWJSJQKdtTKx4CvAhc555pCU1KEc85POfvqPTB2Nlz9OGRPCHdVIhLFgu2sfQhIBl4xPw56lXPulqCrilR9L/KZtQiu+ndd5CMiwy6oIHfOTQ1VIRHvyF5/kc/edXDp1/2t13SRj4iMAA2fCIXda+Cpa6GtEa5+AqZ/ItwViUgMUZAHa/3j8OztMKYYrvu9xoeLyIhTkJ+qzg549Rv+ZsiTLoTPPgZpueGuSkRikIL8VDQfht8uge3/D+Z/ARbeB/GJ4a5KRGKUgnyoqrcG7uSzC678kb8hsohIGCnIh+L9V/zl9vFJcP2zMPHD4a5IRER3CBoU52DFD+HXn4WcibD0TwpxERk11CI/mfZmPyplw1Mw86/gr/5dN0UWkVFFQX4iR/b6m0Ds/TNceidc8I+6yEdERh0F+fFUrvUh3tbg50uZ/slwVyQickwK8mNZ/4TvTskcC3/7NBTNDHdFIiLHpSDvq6sTXrnLX+RTdgF87he6yEdERj0FebfmWj9/+LZXYf5SWPhtXeQjIhFBQQ5w8H1/kc/hCrjyhzDvhnBXJCIyaArytiZ4ZCFgcP0zMHFBuCsSERkSBXnlGmiqgc8/pRAXkYikKzsrVoDF6UpNEYlYCvKKlf7emilZ4a5EROSUxHaQd7T6rpWJ54e7EhGRUxbbQb7nz9DRor5xEYlosR3kFW/4ZwW5iESwGA/ylVA4U1dvikhECyrIzexeM9tgZuvN7GUzKw5VYcOusx12vQUTzwt3JSIiQQm2Rf4vzrkznXNzgD8AdwVf0gjZtwHaG9WtIiIRL6ggd84d6bOYDrjgyhlBPf3japGLSGQL+spOM7sPuA6oAy45wXZLgaUApaWlwR42eBUrIW8qZBaFuxIRkaCctEVuZq+a2aZjPK4CcM7d4ZybAPwa+NLx9uOcW+acK3fOlRcUFITuG5yKrk6oeFOtcRGJCidtkTvnLh/kvh4HngO+EVRFI+HAO9BapyAXkagQ7KiVaX0WPwW8G1w5I6RihX8uU5CLSOQLto/8fjM7HegCKoBbgi9pBFSsgOxSyCoJdyUiIkELKsidc58JVSEjxjn/Q+e0heGuREQkJGLvys7q9/z84+pWEZEoEXtBrvlVRCTKxGCQr4TMYsiZFO5KRERCIraC3DnYucK3xs3CXY2ISEjEVpAf2gEN+9U/LiJRJbaCvHv8uC4EEpEoEmNBvhLS8iH/tHBXIiISMrEV5OofF5EoFDtBXrsL6nZBmW60LCLRJXaCvGKlf9b4cRGJMrET5DvfgJQsKJwV7kpEREIqdoK8YiWULoC42PnKIhIbYiPV6vfDoe0aPy4iUSk2grxn/Lj6x0Uk+sRGkO9cAUkZMPascFciIhJysRHkFSthwjkQH/S9pkVERp3oD/LGGqjeov5xEYla0R/ku7rHjyvIRSQ6RX+Q71wBCSlQPDfclYiIDIvoD/KKFVDyIUhICnclIiLDIrqDvLkW9m/U/CoiEtWiO8h3vwU4jR8XkagWkiA3s380M2dm+aHYX8jsfAPiEn3XiohIlAo6yM1sAvARYFfw5YRYxUoYPw8SU8NdiYjIsAlFi/wHwD8BLgT7Cp3WBti7TuPHRSTqBRXkZvYpYI9z7i+D2Hapma01s7XV1dXBHHZwKleD69T4cRGJeie9Zt3MXgXGHmPVHcDXgI8O5kDOuWXAMoDy8vLhb73vXAEWDxPmD/uhRETC6aRB7py7/Fjvm9lsYBLwF/P3wCwB/mxm851z+0Na5amoWAnFcyA5M9yViIgMq1PuWnHObXTOFTrnypxzZUAlMHdUhHh7M+xZq2GHIhITonMc+Z63obMNJupCIBGJfiGb1zXQKh8ddq4ADErPDXclIiLDLjpb5BUrYOwZkJod7kpERIZd9AV5RxvsXq1hhyISM6IvyPeth45mBbmIxIzoC/Kdb/hnjVgRkRgRfUFesQIKpkP66Jq/S0RkuERXkHd2wK631BoXkZgSXUG+fwO01at/XERiSnQFeYVutCwisSfKgnwF5E6GMePCXYmIyIiJniDv6vItcvWPi0iMiZ4gr9oMLbWaX0VEYk70BHlP/7ha5CISW6IoyN+ArAmQMzHclYiIjKiQzX4YVs75FvmUS8NdiUjMaW9vp7KykpaWlnCXEjVSUlIoKSkhMTFxUNtHR5AffB8aqzXsUCQMKisryczMpKysjMDdwiQIzjlqamqorKxk0qRJg/pMdHStVKzwzwpykRHX0tJCXl6eQjxEzIy8vLwh/QsneoI8owjypoS7EpGYpBAPraGez8gPcuf8HYEmLgD9YRKRGBT5QX54J9TvVbeKiIyYxx9/nKSkJL71rW/1e/+VV15h3rx5zJ49m3nz5vHaa6+NSD2R/2Nn9/jxMl0IJCLD77XXXuN73/semzdvZsmSJZSUlHDDDTcAkJ+fz7PPPktxcTGbNm1i4cKF7NmzZ9hrioIgXwGpuZB/ergrEYl59zz7Dpv3HgnpPmcWj+EbV8467vqvf/3r5Ofnc/vttwNwxx13UFRUxG233XbKx7zqqqv4zGc+w3XXXcdPf/pTXn/9dX7961+zceNG7rzzTl566SWKiop4/vnnWbRoEePGjWPhwoWcffbZPfuYNWsWLS0ttLa2kpycfMq1DEZ0BPnEBRAX+b1EIjJ0S5Ys4dOf/jS33347XV1dPPnkk6xevfqo7S644ALq6+uPev+BBx7g8ssv7/fesmXLOO+885g0aRIPPvggq1atAmD27NmsXLmyZ7v09HRefvnlY9b1u9/9jrPPPnvYQxyCDHIzuxu4GagOvPU159zzwRY1aHV7fB/5/C+M2CFF5PhO1HIeLmVlZeTl5bFu3ToOHDjA2WefTV5e3lHbLV++fND7LCoq4pvf/CaXXHIJTz/9NLm5uUOq6Z133uGrX/3qcUM+1ELRIv+Bc+6BEOxn6Hr6x/VDp0gsu+mmm3j00UfZv38/ixcvPuY2Q2mRA2zcuJG8vDz27t07pFoqKytZtGgRv/jFL5gyZWSGREd210rFG5CcBUVnhLsSEQmjRYsWcdddd9He3s7jjz9+zG2G0iJfvXo1L7zwAuvWreOiiy7iox/96KCusqytreWTn/wk3/nOdzjvvJFrYIaiY/lLZrbBzB4xs5zjbWRmS81srZmtra6uPt5mQ1OxEkrPhbj40OxPRCJSUlISl1xyCZ/73OeIjw8uD1pbW7n55pt55JFHKC4u5sEHH2Tx4sU450762Yceeoht27Zx7733MmfOHObMmUNVVVVQ9QyGnaw4M3sVGHuMVXcAq4CDgAPuBcY5547975o+ysvL3dq1a4debV8NVfDANLj8Hjj/y8HtS0RO2ZYtW5gxY0ZYa+jq6mLu3Ln85je/Ydq0aWGtJVSOdV7N7G3nXPnAbU/ateKcO7rz6BjM7GfAHwZbZNA0flxEgM2bN3PFFVewaNGiqAnxoQp21Mo459y+wOIiYFPwJQ1SxQpITIdxZ43YIUVk9Jk5cyY7duwIdxlhFeyPnd8zszn4rpWdwMiNA6xYCRPmQ/zg5usVEYlWQQW5c+5vQ1XIkDQdggPvwCV3hOXwIiKjSWReDrnrTcBp/LiICJEa5BUrIT4ZiueGuxIRkbCLzCDf+QaUfAgSU8JdiYhEobvvvpsHHjj1C9bXrVvHTTfddMJtHnroIX7+85+f8jH6irwgbzkC+zf4ibJEREahb3/729x6660n3Gbx4sX86Ec/CsnxIu8S/d1vgetS/7jIaPTC/4H9G0O7z7Gz4eP3H3f1cExj29f69eu55ZZbaGpqYsqUKTzyyCPk5OSwZs0alixZQnp6Oueffz4vvPACmzZtor6+ng0bNnDWWX5o9G233UZ+fj533XUXL730Evfddx9/+tOfSEtLo6ysjNWrVzN//vygaoy8FnnFCohL8F0rIhLzlixZwmOPPQbQM43ttddee9R2F1xwQc9l830fr7766gn3f9111/Hd736XDRs2MHv2bO655x4AbrzxRn7yk5/w5ptv9psWYO3atZxxRu/8T/fffz9PPfUUf/zjH7ntttv4+c9/Tlxg2u3y8vIhzQFzPJHXIt+5wv/ImZQe7kpEZKATtJyHy3BMY9utrq6O2tpaLrroIgCuv/56PvvZz1JbW0t9fT0LFvgu3muuuYY//MFf2L5v3z4KCgp69pGWlsbPfvYzLrzwQn7wgx/0mxGxsLCQd999d8h1DRRZQd7WBHv/DB/+UrgrEZFRZDimsT2RE81RlZqaSktLS7/3jjclbktLC6mpqUM69rFEVtdK5Wro6tD8KiLSz6JFi3jxxRdZs2YNCxcuPOY2y5cvZ/369Uc9ThTiWVlZ5OTk9LTmf/nLX3LRRReRk5NDZmZmz52DnnzyyZ7PzJgxg23btvUsV1RU8OCDD7Ju3TpeeOEF3nrrrZ51W7du7dcNc6oiq0VesRIsDiacE+5KRGQU6Z7GNjs7O+hpbAd67LHHen7snDx5cs+QwYcffpibb76Z9PR0Lr74YrKysgCYPn06dXV11NfXk5GRwZIlS3jggQcoLi7m4Ycf5oYbbmDNmjWkpKSwYsUKvvGNbwRdY2QFeVYJzLkGUsaEuxIRGUW6urpYtWoVv/nNb0Kyv7vvvrvn9Zw5c3pa3n3NmjWLDRs2AP4HzfLy3tllFy9ezFNPPcVNN93U78fUefPmsXGjH9Wzbt06Zs2aRX5+ftD1RlbXytzr4Kofh7sKERlFNm/ezNSpU7nssstGdBrb5557jjlz5nDGGWewfPly7rzzzp51X/ziF0960+WDBw9y7733hqSWk95YYjiE5MYSIjIqjIYbS0SjodxYIrJa5CIyKoWjQRjNhno+FeQiEpSUlBRqamoU5iHinKOmpoaUlMHPJRVZP3aKyKhTUlJCZWUlIbupupCSkkJJScmgt1eQi0hQEhMTmTRpUrjLiGnqWhERiXAKchGRCKcgFxGJcGEZR25m1UDFKXw0HzgY4nIijc6BzgHoHEBsnoOJzrmCgW+GJchPlZmtPdZg+Fiic6BzADoHoHPQl7pWREQinIJcRCTCRVqQLwt3AaOAzoHOAegcgM5Bj4jqIxcRkaNFWotcREQGUJCLiES4URfkZvYxM3vPzLaZ2f85xnozsx8F1m8ws7nhqHM4DeIcXBv47hvMbKWZnRWOOofTyc5Bn+0+ZGadZvbXI1nfSBjMOTCzi81svZm9Y2b/M9I1DrdB/F3IMrNnzewvgXNwYzjqDDvn3Kh5APHAdmAykAT8BZg5YJtPAC8ABpwLvBXuusNwDhYAOYHXH4/Fc9Bnu9eA54G/DnfdYfhzkA1sBkoDy4XhrjsM5+BrwHcDrwuAQ0BSuGsf6cdoa5HPB7Y553Y459qAJ4GrBmxzFfAL560Css1s3EgXOoxOeg6ccyudc4cDi6uAwc93GRkG8+cA4Fbgd0DVSBY3QgZzDq4B/ss5twvAORdt52Ew58ABmWZmQAY+yDtGtszwG21BPh7Y3We5MvDeULeJZEP9fkvw/0KJJic9B2Y2HlgE/GQE6xpJg/lzcBqQY2Z/MrO3zey6EatuZAzmHDwEzAD2AhuB251zXSNT3ugx2uYjt2O8N3B85GC2iWSD/n5mdgk+yM8f1opG3mDOwb8CX3XOdfrGWNQZzDlIAOYBlwGpwJtmtso5t3W4ixshgzkHC4H1wKXAFOAVM1vunDsyzLWNKqMtyCuBCX2WS/D/px3qNpFsUN/PzM4E/hP4uHOuZoRqGymDOQflwJOBEM8HPmFmHc65/x6RCoffYP8uHHTONQKNZvY6cBYQLUE+mHNwI3C/853k28zsA2A6sHpkShwdRlvXyhpgmplNMrMk4GrgmQHbPANcFxi9ci5Q55zbN9KFDqOTngMzKwX+C/jbKGp99XXSc+Ccm+ScK3POlQG/Bf4uikIcBvd34ffABWaWYGZpwDnAlhGuczgN5hzswv+LBDMrAk4HdoxolaPAqGqRO+c6zOxLwEv4X6wfcc69Y2a3BNb/BD9C4RPANqAJ/3/kqDHIc3AXkAf8e6BF2uGiaBa4QZ6DqDaYc+Cc22JmLwIbgC7gP51zm8JXdWgN8s/BvcCjZrYR3xXzVedcrE1tq0v0RUQi3WjrWhERkSFSkIuIRDgFuYhIhFOQi4hEOAW5iEiEU5CLiEQ4BbmISIT7/+cZugIyhflhAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = np.sort(np.random.random(30))\n",
    "b = a**2\n",
    "c = np.log(a)\n",
    "plt.plot(a, b, label='y = x^2')\n",
    "plt.plot(a, c, label='y = log(x)')\n",
    "plt.legend()\n",
    "plt.title(\"Some functions\")\n",
    "plt.show()"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}