Numpy_PyData_DEL_2019.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code slide Part -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy\n",
    "=====\n",
    "\n",
    "Provides\n",
    "  1. An array object of arbitrary homogeneous items\n",
    "  2. Fast mathematical operations over arrays\n",
    "  3. Linear Algebra, Fourier Transforms, Random Number Generation\n",
    "  \n",
    "For more information about introduction to NumPy. Read this [Doc](https://docs.scipy.org/doc/numpy-1.13.0/user/whatisnumpy.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "numpy_array = np.array([1, 2, 3.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ndarray = block of memory + indexing scheme + data type descriptor\n",
    "\n",
    "        raw data\n",
    "        how to locate an element\n",
    "        how to interpret an element\n",
    "\n",
    "Ref: [Link](http://scipy-lectures.org/advanced/advanced_numpy/#id4)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_array #Typecasted to float to maintain homogenity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_array.dtype "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[List of Supported Data Types](https://docs.scipy.org/doc/numpy/user/basics.types.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(numpy_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.float64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(numpy_array[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'numpy.ndarray' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-bcbac6984c7e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnumpy_array\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m9.0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Should throw error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "numpy_array.append(9.0) # Should throw error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NOTE\n",
    "\n",
    "Numpy arrays are fixed size arrays unlike Python List/Dict ojects which are dynamic in nature.\n",
    "Any insertion/deletion/concatination when/if performed creates a new copy of the array.\n",
    "How this strict rule of homogenity and size helps Numpy? \n",
    "We will witness shortly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code Slide Part-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1,2,3],[4,5,6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(24, 8)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.strides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The strides of an array tell us how many bytes we have to skip in memory to move to the next position along a certain axis.\n",
    "This StackOveflow Q/A explains it quite well. [Link](https://stackoverflow.com/questions/53097952/how-to-understand-numpy-strides-for-layman)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a.T # Transpose of a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 24)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.strides"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a.reshape((6)) # Convert in 1-D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6,)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8,)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.strides"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25869168"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.__array_interface__['data'][0] # kinda databuff mem position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25869168"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.__array_interface__['data'][0] # kinda databuff mem position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25869168"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.__array_interface__['data'][0] # kinda databuff mem position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "databuff_mem_loc_a = a.__array_interface__['data'][0]\n",
    "databuff_mem_loc_b = b.__array_interface__['data'][0] \n",
    "databuff_mem_loc_c = c.__array_interface__['data'][0]\n",
    "assert(databuff_mem_loc_a == databuff_mem_loc_b == databuff_mem_loc_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code Slide Part-3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (A): Glimpse of Universal functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "b = np.array([2, 3, -1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  6, -3])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b # Common Mathematical operations are overridden for arrays\n",
    "# Element wise multiplication. Use np.dot for matrix multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.greater(a,b) # Comparision function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logical_and(a>0, b>0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(a) # Univariate functions, takes in single argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, a ufunc is a “vectorized” wrapper for a function that takes a fixed number of specific inputs,\n",
    "and produces a fixed number of specific outputs. \n",
    "-Numpy Docs.\n",
    "\n",
    "Complete list of uFuncs: [Link](https://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (B): Execution Time Comparision for * operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from time import time\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_time_taken(object_size):\n",
    "    python_list = list(range(object_size))\n",
    "    start_ = time()\n",
    "    _ = [element * element for element in python_list]\n",
    "    end_ = time()\n",
    "    del(python_list)\n",
    "    del(_)\n",
    "    time_taken_lists = end_ - start_\n",
    "    numpy_array = np.arange(object_size)\n",
    "    start_ = time()\n",
    "    numpy_array*numpy_array\n",
    "    end_ = time()\n",
    "    del(numpy_array)\n",
    "    time_taken_np = end_ - start_\n",
    "    return (time_taken_lists, time_taken_np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(columns=[\"C\", \"tL\", \"tN\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "object_size = 1\n",
    "while object_size !=100000000:\n",
    "    results = return_time_taken(object_size)\n",
    "    df = df.append({\"C\": object_size, \"tL\": results[0], \"tN\": results[1]},ignore_index=True) #Optimise this\n",
    "    object_size *= 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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>C</th>\n",
       "      <th>tL</th>\n",
       "      <th>tN</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000002</td>\n",
       "      <td>0.000012</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10.0</td>\n",
       "      <td>0.000003</td>\n",
       "      <td>0.000005</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100.0</td>\n",
       "      <td>0.000009</td>\n",
       "      <td>0.000010</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000.0</td>\n",
       "      <td>0.000071</td>\n",
       "      <td>0.000008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10000.0</td>\n",
       "      <td>0.000654</td>\n",
       "      <td>0.000024</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>100000.0</td>\n",
       "      <td>0.006504</td>\n",
       "      <td>0.000207</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1000000.0</td>\n",
       "      <td>0.050355</td>\n",
       "      <td>0.003031</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>10000000.0</td>\n",
       "      <td>0.470921</td>\n",
       "      <td>0.031979</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            C        tL        tN\n",
       "0         1.0  0.000002  0.000012\n",
       "1        10.0  0.000003  0.000005\n",
       "2       100.0  0.000009  0.000010\n",
       "3      1000.0  0.000071  0.000008\n",
       "4     10000.0  0.000654  0.000024\n",
       "5    100000.0  0.006504  0.000207\n",
       "6   1000000.0  0.050355  0.003031\n",
       "7  10000000.0  0.470921  0.031979"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.plot(x=\"C\",y=[\"tL\",\"tN\"], figsize=(10,5), grid=True)\n",
    "plt.xlabel(\"Size of Object\")\n",
    "plt.ylabel(\"Time in(sec)\")\n",
    "plt.legend([\"List looping\", \"Numpy Vectorization\"])\n",
    "plt.title(\"Input Object Size vs. Execution Time for *\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}