numpy/Full_Numpy_Tutorial_for_DeepLearners.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1,2,3]\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "for i in L:\n",
    "    print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[1 2 3]\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "B = np.array([1,2,3])\n",
    "for e in B:\n",
    "    print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 6])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = B + B\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4,  8, 12])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = B*2\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = L*2\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for ** or pow(): 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-9c714a1bea7b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mL\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'list' and 'int'"
     ]
    }
   ],
   "source": [
    "L**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "L2 = []\n",
    "for i in L:\n",
    "    L2.append(i*i)\n",
    "print(L2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L.append(4)\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2.        ,  2.82842712,  3.46410162])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.38629436,  2.07944154,  2.48490665])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  5.45981500e+01,   2.98095799e+03,   1.62754791e+05])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A bit about dot product\n",
    "\n",
    "1. First method: $a.b = a^{T} = \\sum_{d = 1}^ba_{d}b_{d}$\n",
    "2. Second method: $a.b = |a||b|cos\\theta_{ab}$ - not really convenient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([1,2])\n",
    "b = np.array([2,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dot = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i,j in zip(a,b):\n",
    "    dot += i*j\n",
    "dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## A matrix is essentially a list of lists\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "M = np.array([[1,2], [3,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "L = [[1,2], [3,4]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "M2 = np.matrix([[1,2], [3,4]]) #works somewhat similarly to np.array but not exactly same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2],\n",
       "        [3, 4]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A = np.array(M2) # converting it into a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A # you get the same matrix but as an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [2, 4]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.T # Transposing values with T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summarizing: \n",
    "A matrix is just a 2-dimensional numpy array and a vector is a 1-dimensional numpy array. Or you can see it this way: A matrix is actually like a 2-dimensional vector (a 2-dimensional math object that contains numbers) and a vector is a 1-dim mathematical object containing numbers).<br>\n",
    "A col vector is 3x1 and a row vector is 1x3. All you need to remember is 1-D array, which is a vector and 2 or multiple dimensional arrays that are matrices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Different ways in generating data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1,2,3,4]) #tedious way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Z = np.zeros(10) #gives us a vector of 10s using function zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z # will give you a vector with length 10 of all zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Z = np.zeros((10, 10)) # for a matrix of 10x10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "O = np.ones((10, 10)) # for ones use ones function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "O # gives you a 10x10 matrix with all numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "RandomNumbers = np.random.random((10,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.21120153,  0.47901791,  0.11209704,  0.11863526,  0.37906729,\n",
       "         0.92196915,  0.55395531,  0.01230503,  0.61684901,  0.95996838],\n",
       "       [ 0.34651404,  0.29820884,  0.51718731,  0.41805369,  0.13795797,\n",
       "         0.40556349,  0.69044765,  0.22044075,  0.22896156,  0.9509594 ],\n",
       "       [ 0.41659618,  0.3259565 ,  0.44736091,  0.71775607,  0.01287519,\n",
       "         0.45027851,  0.37898059,  0.42574621,  0.76908728,  0.12382397],\n",
       "       [ 0.9260382 ,  0.34311614,  0.59904369,  0.97371333,  0.60913998,\n",
       "         0.86524465,  0.80235174,  0.04136983,  0.93875914,  0.72019736],\n",
       "       [ 0.62276295,  0.84808579,  0.82941885,  0.20383706,  0.4103066 ,\n",
       "         0.52055116,  0.62107374,  0.68679222,  0.19335086,  0.65345861],\n",
       "       [ 0.49393662,  0.62137473,  0.17332213,  0.66717989,  0.83161585,\n",
       "         0.00186206,  0.66366877,  0.06813097,  0.92824793,  0.73455723],\n",
       "       [ 0.48517262,  0.60504421,  0.98354616,  0.62245544,  0.86598766,\n",
       "         0.64805293,  0.94381287,  0.45522972,  0.55244892,  0.26343961],\n",
       "       [ 0.77525341,  0.6225836 ,  0.79688705,  0.87440051,  0.69414093,\n",
       "         0.45579995,  0.12017669,  0.43824982,  0.07937431,  0.87811489],\n",
       "       [ 0.10317853,  0.66083241,  0.76779113,  0.26389426,  0.57385693,\n",
       "         0.06486179,  0.44039983,  0.76236668,  0.09948997,  0.67474595],\n",
       "       [ 0.13987567,  0.43081388,  0.70946981,  0.57169882,  0.99947337,\n",
       "         0.40933874,  0.5766611 ,  0.07384601,  0.82832888,  0.76325666]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RandomNumbers # in a matrix of size 10x10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object cannot be interpreted as an integer",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-57-fd8dddc7d957>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mGaussianNumbers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32mmtrand.pyx\u001b[0m in \u001b[0;36mmtrand.RandomState.randn (numpy/random/mtrand/mtrand.c:19888)\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32mmtrand.pyx\u001b[0m in \u001b[0;36mmtrand.RandomState.standard_normal (numpy/random/mtrand/mtrand.c:20413)\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;32mmtrand.pyx\u001b[0m in \u001b[0;36mmtrand.cont0_array (numpy/random/mtrand/mtrand.c:6141)\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object cannot be interpreted as an integer"
     ]
    }
   ],
   "source": [
    "GaussianNumbers = np.random.randn((10,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# It failed becuase Randn function takes each of the dimensions as individual objects, while all others took tuples.\n",
    "GaussianNumbers = np.random.randn(10,10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.68715898,  1.70957064, -0.49413892,  1.8085133 , -0.47995667,\n",
       "        -0.99631681, -0.03483488,  0.10364919, -1.74888617, -0.05288246],\n",
       "       [ 0.13230323, -1.77476145, -1.76054082, -0.91910353,  1.32920813,\n",
       "        -1.49278408,  0.14730228, -0.11704294,  1.3064156 , -1.32119143],\n",
       "       [-0.88801676, -0.20940957, -0.55494878, -1.29069601,  0.07834724,\n",
       "         1.46256306, -0.36509951,  0.16695521, -0.45218099,  0.64966003],\n",
       "       [-0.85027652,  0.15363516,  0.13909775, -0.18193521, -0.99241748,\n",
       "         0.14753979, -0.52074068,  0.35435607,  0.09266545,  0.49681165],\n",
       "       [-0.96709848, -0.13834602, -0.79542029, -2.05586873, -0.57153614,\n",
       "        -0.16953559,  1.36242053, -0.26879473, -0.86338223,  0.36295536],\n",
       "       [-0.07764097, -0.13527146,  0.97497771,  1.2137657 ,  0.58948152,\n",
       "         0.35392521, -0.30203594,  0.65413691,  0.51291529, -0.18268169],\n",
       "       [-0.65686254,  1.73383794,  1.37188017,  2.90443151, -0.87088647,\n",
       "        -1.39967227, -0.27437272, -0.69591497, -0.03851213,  1.88680172],\n",
       "       [-0.39397933,  0.93069638,  0.19270916, -1.8269362 ,  0.29512428,\n",
       "        -0.02382181, -0.75292469, -0.1045992 , -1.25294074,  0.08112434],\n",
       "       [ 1.92902654,  0.00477516, -1.62042722,  0.58564808, -0.91936531,\n",
       "        -0.8962867 ,  0.24508394, -0.58760256,  1.69533206,  0.08038545],\n",
       "       [-0.37502611, -0.00944067,  0.22334797,  1.39306979, -1.17506557,\n",
       "        -0.1019211 , -0.41676484,  0.04902438,  0.94535498,  1.65423295]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GaussianNumbers # will give a gauissian distribution with mean 0 and variance 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.046011973128545033"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GaussianNumbers.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.92682385908640597"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GaussianNumbers.var()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix Products or multiplication\n",
    "1. Matrix multiplication : Inner dimensions must match! if we have A of size (2,3) and B of size (3,3), we can multiply AB (inner dimension is 3) but we cannot multiply BA where inner dimension is 3 and 2!\n",
    "2. The definition of matrix multiplication is as follows: $$C(i,j) = \\sum_{k=1}^K A(i,k)B(k,j)$$\n",
    "3. This means $(i,j)^{th}$ entry of C is the sum of the multiplication of all the corresponding element from $i^{th}$ row of A and $j^{th}$ col of B. In other words, $C(ij)$ is the dot product of $i^{th}$ row of A and $j^{th}$ col of B. That is, $C(ij)$ is the dot product of Because of this we use the dot function in numpy and that does what you see as matrix multiplication.\n",
    "4. Instinctively (in maths that is) you'd want to do an element by element multiplication, for vectors we can do with a * operation, as you may imagine for a 2D array , the * also does an element-wise multiplication ,meaningwhwn you use an * for multidimensional arrya, both must be exactly the same size. This may mean a bit weird, because in other (programming) languages * means real matrix multiplication. So, to summarize -- asterisk(*) means element by element multiplication while dot function does a matrix multiplication.\n",
    "5. One more funny thing in maths equations, there isn't a well defined real symbol to use a element by element multiplication. Sometimes folks use circle with a . insidde or an x.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### More matrix operations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrix inverse\n",
    "A = np.array([[1,2], [3,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_inverse = np.linalg.inv(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2. ,  1. ],\n",
       "       [ 1.5, -0.5]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2. ,  2. ],\n",
       "       [ 4.5, -2. ]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A*A_inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.00000000e+00,   0.00000000e+00],\n",
       "       [  8.88178420e-16,   1.00000000e+00]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.dot(A_inverse) #gives us an identity matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.00000000e+00,   0.00000000e+00],\n",
       "       [  2.22044605e-16,   1.00000000e+00]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_inverse.dot(A) # note this gives us an identity matrix as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.0000000000000004"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matrix determinant\n",
    "np.linalg.det(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A) # gives us diagonal elements in a vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0],\n",
       "       [0, 2]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note this: if you pass a 2D array to diag, you get a 1D array (as above), if you pass a 1D array\n",
    "# 2 get a 2D array where off diagonals are zero as below\n",
    "np.diag([1,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Outer product / inner product\n",
    "1. Outer product: $C(i,j) = A(i)B(j)$\n",
    "    1.1 Example: $$\\sum = E{(x - μ)(x - μ)^T} ≈ \\frac{1}{N-1}\\sum_{n=1}^N(x_n - \\overline{x})(x_n - \\overline{x})T$$\n",
    "2. Inner product: C = sum over i {A(i)B(i)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 4],\n",
       "       [6, 8]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Doing an outer product\n",
    "a = np.array([1,2])\n",
    "b = np.array([3,4])\n",
    "np.outer(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dot product ,as you may recall is also known as inner product\n",
    "np.inner(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dot(b) # same as above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Matrix trace is the sum of the diagonals of a matrix\n",
    "np.diag(A).sum() # See In [92]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Eigenvalues and Eigenvectors\n",
    "X = np.random.randn(100,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "covariance = np.cov(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 100)"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "covariance.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "covariance = np.cov(X.T) # transpose X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.1252023 ,  0.11999687, -0.06056132],\n",
       "       [ 0.11999687,  1.37640392, -0.09390439],\n",
       "       [-0.06056132, -0.09390439,  1.34016558]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "covariance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eigenvalues and Eigenvectors\n",
    "\n",
    "1. eigenvalues, eigenvectors = np.eig(C) # Symmetric matrix is equal of a Transpose of itself\n",
    "or\n",
    "2. eigenvalues, eigenvectors = np.eigh(C) # While a Hermitian matrix ia a conjugate of transpose of itself\n",
    "\n",
    "So, Symmetricc $A = A^T$, while Hermitian matrix of $A = A^H$ or simply $A^H$ is conjugate transpose of A\n",
    "\n",
    "3. Convariance is a symmetric matrix, so we should be able to use eigh..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 1.07513246,  1.26643248,  1.50020688]),\n",
       " array([[ 0.93460371,  0.12595625, -0.33264233],\n",
       "        [-0.34363868,  0.56112674, -0.75302672],\n",
       "        [ 0.09180609,  0.81809034,  0.56771458]]))"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eigh(covariance) #gives a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np.linalg.eigh(covariance))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 1.07513246,  1.50020688,  1.26643248]),\n",
       " array([[-0.93460371,  0.33264233,  0.12595625],\n",
       "        [ 0.34363868,  0.75302672,  0.56112674],\n",
       "        [-0.09180609, -0.56771458,  0.81809034]]))"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eig(covariance) # will give us a tuple, first tuple contains 3 eigenvalues and sector tuple contains eigenvectors stored in columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np.linalg.eig(covariance))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# You may have notice they can be in different order, try running it again to check it out for yourself!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solving a Linear System\n",
    "\n",
    "1. $Ax = b$ # A is matrix, x is col vector of values we are trying to solve for and B is vector of numbers\n",
    "2. Solution = $A^{-1} = x = A^{-1}b$\n",
    "3. Notes: Will be adding soon..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([1,2])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  0.5])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.linalg.inv(A).dot(b)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.linalg.solve(A, b) # much intuitive and efficient way to do it. also more accurate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  0.5])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A simple example...\n",
    "1. Problem description: In a party, singles pay a entry ticket of 2.50 dollars and couples paid for a single 4.00 dollars . At this big rock concert event, some 20,000 tickets were sold and 75,500 dollars was made by the organizers. How many singles and how many couples partied that night?\n",
    "\n",
    "    1.1 X1 = number of singles, X2 = number of couples => \n",
    "    1.2 X1 + X2 = 20,000 => \n",
    "    1.3 2.5X1 + 4.00X2 = 75,000\n",
    "\n",
    "2. As a matrix this is how it looks like: $$ \n",
    "\\begin{bmatrix}\n",
    "    1 & 1 \\\\\n",
    "    2.5 & 4 \\\\\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "    x1 \\\\\n",
    "    x2 \\\\\n",
    "\\end{bmatrix} = \n",
    "\\begin{bmatrix}\n",
    "    20000 \\\\\n",
    "    75000 \\\\\n",
    "\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "party_goers = np.array([[1,1], [2.5,4]]) # This is our 2D matrix A\n",
    "collections = np.array([20000, 75000]) #This is our 1D matrix / vector b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There were  3333.33333333  singles and  16666.6666667  couples; and apparently some one cheated on their partner that night ;)\n"
     ]
    }
   ],
   "source": [
    "np.linalg.solve(party_goers, collections)\n",
    "print(\"There were \", np.linalg.solve(party_goers, collections)[0],\\\n",
    "      \" singles and \", np.linalg.solve(party_goers, collections)[1] ,\\\n",
    "      \" couples; and apparently some one cheated on their partner that night ;)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More stuff coming here!\n",
    "Don't go away as I explain and we learn together the following, we first do a recap so you refresh your thoughts again on:\n",
    "1. Numpy Specific\n",
    "    1.1 Arrays\n",
    "    1.2. Array Indexing\n",
    "    1.3. Datatypes\n",
    "    1.4. Array Math\n",
    "    1.5. Broadcasting\n",
    "2. A super fast refresh on Python lists, dictionaries, classes and functions\n",
    "3. Pandas w.r.t Numpy\n",
    "4. Scipy w.r.t Numpy\n",
    "5. Matplotlib w.r.t Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}