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": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vector Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert list to numpy array\n",
    "np.array([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 1.0, 1.0, 1.0, 1.0]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert numpy array to list\n",
    "np.ones(5).tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3., 4., 5.])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# one float => all floats\n",
    "np.array([1.0,2,3,4,5])"
   ]
  },
  {
   "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": [
    "# same as above\n",
    "np.array([1,2,3,4,5], dtype='float')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 8,
     "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": 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": [
    "# same as above\n",
    "np.arange(0,20,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.31664584, 0.97643913, 0.01118794, 0.43533221, 0.24700291,\n",
       "       0.0995256 , 0.70353265, 0.12178553, 0.5933922 , 0.23113084])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# random floats in [0, 1)\n",
    "np.random.random(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9,  5, 14,  9,  7, 14, 12,  8, 14,  8])"
      ]
     },
     "execution_count": 11,
     "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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([10,20,30,40,50])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slice\n",
    "x[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30, 40, 50])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0:1000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# last value\n",
    "x[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([50])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# last value as array\n",
    "x[[-1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 40, 50])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# last 3 values\n",
    "x[-3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 30, 50])"
      ]
     },
     "execution_count": 19,
     "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": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#x2 = x # try this line instead\n",
    "x2 = x.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30, 40, 50])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[0] = 10\n",
    "\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10, 40, 50])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[[1,2]] = 10\n",
    "\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 10, 10,  0,  1])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[[3,4]] = [0, 1]\n",
    "\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30, 40, 50])"
      ]
     },
     "execution_count": 24,
     "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": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.30258509, 2.99573227, 3.40119738, 3.68887945, 3.91202301])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.20264658e+04, 4.85165195e+08, 1.06864746e+13, 2.35385267e+17,\n",
       "       5.18470553e+21])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 20,  40,  60,  80, 100])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + x  # Try also with *, -, /, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 21, 31, 41, 51])"
      ]
     },
     "execution_count": 32,
     "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": 33,
   "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": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.07814575, 1.85554186, 1.41576594, ..., 1.40744161, 1.99557161,\n",
       "       1.88252576])"
      ]
     },
     "execution_count": 34,
     "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": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 69.1 ms, sys: 16.3 ms, total: 85.4 ms\n",
      "Wall time: 84.3 ms\n"
     ]
    }
   ],
   "source": [
    "%time _ = np.log(samp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 10.4 s, sys: 123 ms, total: 10.5 s\n",
      "Wall time: 10.5 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": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([[1,2,3], [4,5,6]])"
   ]
  },
  {
   "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]], dtype='float')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "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": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "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": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.identity(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag([1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.array([[1,2,3], [4,5,6]])\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get row\n",
    "X[0, : ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get column\n",
    "X[ : , 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [4, 6]])"
      ]
     },
     "execution_count": 48,
     "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": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# X2 = X # try this line instead\n",
    "X2 = X.copy()\n",
    "\n",
    "X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[20,  2,  3],\n",
       "       [ 4,  5,  6]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X2[0,0] = 20\n",
    "\n",
    "X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 3, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X2[0] = 3\n",
    "\n",
    "X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 3, 5],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X2[: , -1] = [5, 6]\n",
    "\n",
    "X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if original matrix changed\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix reshaping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.arange(1, 7)\n",
    "\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6,)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z = z.reshape(2,3)\n",
    "\n",
    "Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z.reshape(6)"
   ]
  },
  {
   "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": [
    "# same as above\n",
    "Z.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# transpose\n",
    "Z.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numeric operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [4., 5., 6.]])"
      ]
     },
     "execution_count": 61,
     "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": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  4.,  9.],\n",
       "       [ 4., 10., 18.]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# not the same as A.dot(B)\n",
    "A * B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 4., 6.],\n",
       "       [5., 7., 9.]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 1. , 1. ],\n",
       "       [4. , 2.5, 2. ]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A / B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14., 32.])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matrix multiplication\n",
    "A.dot(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14., 32.])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.dot(A.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14., 32.],\n",
       "       [32., 77.]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.dot(A.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [2, 4, 6],\n",
       "       [3, 6, 9]])"
      ]
     },
     "execution_count": 69,
     "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://cs231n.github.io/optimization-2/), though it is not necessary for our class. Also look at this [neural networks case study](http://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": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "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": 71,
     "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": 72,
   "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": 73,
   "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": 74,
   "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        14\n",
      "  versicolor       0.93      0.87      0.90        15\n",
      "   virginica       0.88      0.94      0.91        16\n",
      "\n",
      "    accuracy                           0.93        45\n",
      "   macro avg       0.94      0.93      0.94        45\n",
      "weighted avg       0.93      0.93      0.93        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": 75,
   "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": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3771955806549263"
      ]
     },
     "execution_count": 76,
     "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": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.34864704876297153, 0.32347459326674544)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pearson correlation (coeff, p-value)\n",
    "pearsonr(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "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": 78,
     "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": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "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": "nlu",
   "language": "python",
   "name": "nlu"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}