py/PythonCrashCourse_Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy Package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "#import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Document and Auto-completion in Jupyter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.full"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.[TAB]\n",
    "np.abs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Help document\n",
    "np.random.normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# [Sh-Tab] to show function arguments\n",
    "m = np.random.normal(loc=0, scale=2, size=(3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m.ndim, m.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vector & Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[0, 1, 2, 3, 4, 5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.array([0, 1, 2, 3, 4, 5, 6])\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(t)\n",
    "print(t.ndim) # rank/dimension\n",
    "print(t.shape) # shape\n",
    "print(t[0], t[1], t[-1])\n",
    "print(t[2:5], t[3:-1])\n",
    "print(t[:2], t[3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_x = np.array([2, 5, 2])\n",
    "mat_A = np.array([[1, 0.7, -0.2], [0.2, 1, 0.5], [0.2, -0.5, 1]])\n",
    "print(vec_x, '\\n', mat_A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Vector * Vector (Matrix * Matrix): Component-wise\n",
    "print(vec_x * vec_x, '\\n')\n",
    "print(mat_A * mat_A, '\\n')\n",
    "\n",
    "# Matrix x Vector ??: component-wise in each vector\n",
    "print( mat_A * vec_x, '\\n')\n",
    "print( vec_x * mat_A, '\\n') # Same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(12).reshape((3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat_B = np.arange(12).reshape((3,4))\n",
    "vec_y = np.arange(4)\n",
    "print(mat_B, vec_y)\n",
    "mat_B * vec_y "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dot(inner) product\n",
    "vec_y = vec_x + 1\n",
    "print( np.dot(vec_x, vec_y) )\n",
    "print( vec_x.dot(vec_y) ) # same\n",
    "print( vec_x@vec_y )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Matrix multiplication ?\n",
    "print(mat_A @ mat_A, '\\n')\n",
    "# print(np.matmul(mat_A, mat_A), '\\n')  # @ is exactly same as np.matmul\n",
    "\n",
    "print(mat_A @ vec_x, '\\n')  # vec_x is treated as a column vector\n",
    "\n",
    "print(vec_x @ mat_A) # vec_x is treated as a row vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#vec_x.reshape((3,1))\n",
    "vec_x[:, None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert vector to a matrix with single column\n",
    "vec_x_col = vec_x[None, :, None]\n",
    "print(vec_x_col)\n",
    "print( np.reshape(vec_x,(3,1)) )\n",
    "print( vec_x.reshape((3,1)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_x = np.arange(5)\n",
    "print(vec_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_x[:,None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAT = vec_x * vec_x[:,None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAT[1,:,None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mat_A, vec_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat_A * vec_x[:, None]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## N-d Array Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_y = np.ones(10)\n",
    "vec_z = np.zeros((5,3), dtype=float)\n",
    "print(vec_z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#mat_B = np.zeros((3,3))\n",
    "mat_B = np.zeros_like(mat_A)\n",
    "mat_B = np.ones_like(mat_A)\n",
    "print(mat_B)\n",
    "\n",
    "x_norm = np.random.normal(10,2,size=(10000,5))\n",
    "x_unif = np.random.uniform(size=(10000,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_unif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operations on Matrix (N-d array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Axis 0: Column, Axis 1: Row\n",
    "print( np.mean(x_norm, axis=0) )\n",
    "print( np.std(x_norm, axis=0) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( np.mean(x_norm) )\n",
    "print( np.mean(x_norm,axis=0) )\n",
    "print( np.mean(x_norm,axis=1) )\n",
    "print( np.mean(x_norm,axis=(0,1)) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random Walk Simulation\n",
    "x_rw = np.random.binomial(1,0.5,size=(1000,10))*2 - 1\n",
    "x_rw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_cum = np.cumsum(x_rw, axis=0)\n",
    "print(x_cum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x_cum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat_B = np.arange(12).reshape((3,4))\n",
    "vec_x = np.arange(4)\n",
    "vec_y = np.arange(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat_B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.vstack([mat_B, mat_B]))\n",
    "print(np.vstack([mat_B, vec_x]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.hstack([mat_B, mat_B]))\n",
    "#print(np.hstack([mat_B, vec_y]))\n",
    "print(np.hstack([mat_B, vec_y[:,None]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Vectorization is fast\n",
    "* Using `for` or `while` loop is very slow\n",
    "* Always find proper vectorization operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We're going to simulate the mean of the maximum of 5 normal distribution.\n",
    "nn = 100000\n",
    "x_norm = np.random.normal(size=(nn,5))\n",
    "x_norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "x_max = np.ones(x_norm.shape[0])\n",
    "for k in range(nn):\n",
    "    x_max[k] = max(x_norm[k,:])\n",
    "val = x_max.mean()\n",
    "print(f'mean = {val}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectorized Version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "val = np.amax(x_norm, axis=1).mean()\n",
    "print(f'mean = {val}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array view and Copy\n",
    "* Array view shares the same memory space\n",
    "* Any change in the view will make the same change in the original array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat_B = np.arange(12).reshape((3,4))\n",
    "#print(mat_B)\n",
    "#vec_x = mat_B[1,]\n",
    "vec_x = mat_B[1,].copy()\n",
    "print(mat_B, vec_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_x[2] = -99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mat_B, vec_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mat_C is not a view\n",
    "mat_B = np.arange(12).reshape((3,4))\n",
    "mat_C = mat_B.copy()\n",
    "mat_C[1,1] = -99\n",
    "print(mat_B, \"\\n\\n\", mat_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}