numpy_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python/NumPy help session\n",
    "\n",
    "(Material is modified from the cs231n numpy tutorial, python official documentation, and some extra stuff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Data types "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "<class 'int'>\n",
      "3 4 15 9\n",
      "8\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "#integer\n",
    "x = 3\n",
    "print(x)\n",
    "print(type(x))\n",
    "\n",
    "print(x, x + 1, x * 5, x ** 2) #exponential is not ^ \n",
    "\n",
    "x += 5 # x = x + 5\n",
    "print(x)\n",
    "\n",
    "x *= 3\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "<class 'float'>\n",
      "2.0 3.0 10.0 4.0\n"
     ]
    }
   ],
   "source": [
    "#floating point\n",
    "y = 2.\n",
    "print(y)\n",
    "print(type(y))\n",
    "\n",
    "print(y, y + 1, y * 5, y ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'> <class 'bool'>\n",
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#boolean\n",
    "z, w = True, False\n",
    "\n",
    "print(type(z), type(w))\n",
    "\n",
    "print(z or w) #logical operations\n",
    "print(z and w) \n",
    "print(not z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a1 =  machine\n",
      "a2 =  learning\n",
      "machine learning is awesome\n",
      "<class 'str'> <class 'str'> <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "#strings ##numpy tutorial from cs 231n ( ) \n",
    "a1 = 'machine'\n",
    "a2 = \"learning\" ##absolutely fine, it treats them similarly\n",
    "\n",
    "print('a1 = ', a1)\n",
    "print('a2 = ', a2)\n",
    "\n",
    "a3 = a1 + \" \" + a2 + ' is awesome'\n",
    "print(a3)\n",
    "\n",
    "print(type(a1), type(a2), type(a3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advanced Data Types a.k.a. Containers\n",
    "\n",
    "(only go through lists and dictionaries) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> [1, 2, 3, 4, 5]\n",
      "1 3\n",
      "5 1\n"
     ]
    }
   ],
   "source": [
    "# Lists (can think of these as python's implementation of arrays ***, but has several different properties)\n",
    "\n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "print(type(list1), list1)\n",
    "\n",
    "print(list1[0], list1[2])\n",
    "\n",
    "print(list1[-1], list1[-5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "list1[0] = 10\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 2, 3, 4, 5, 'ML']\n",
      "[10, 2, 3, 4, 5]\n",
      "[10, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "list1.append(\"ML\") ##add operation \n",
    "print(list1)\n",
    "\n",
    "list1.pop() ##remove operation\n",
    "print(list1)\n",
    "\n",
    "list1.pop()\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "slicing (aka indexing or extracting out \"useful parts\") of lists\n",
    "remember that the second index is always excluded! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2, 3]\n",
      "[7, 8]\n"
     ]
    }
   ],
   "source": [
    "list2 = list(range(10))\n",
    "l3 = list2[2:5]\n",
    "#print(list2)\n",
    "#print(l3, type(l3))\n",
    "\n",
    "\n",
    "print(list2[:]) ##all elements\n",
    "print(list2[:4]) ##alll elements until 4th (non inclusive)\n",
    "print(list2[7:-1]) ##all elements after 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to matlab, you can loop over lists! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "cat\n",
      "dog\n",
      "monkey\n"
     ]
    }
   ],
   "source": [
    "animal_list = ['cat', 'dog', 'monkey']\n",
    "print(type(animal_list))\n",
    "\n",
    "for animal in animal_list:\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25]\n",
      "[0, 1, 4, 9, 16, 25]\n",
      "[1, 9, 25]\n"
     ]
    }
   ],
   "source": [
    "mylist = list(range(6))\n",
    "squares = [] #empty\n",
    "\n",
    "for ii in mylist:\n",
    "    squares.append(ii ** 2)\n",
    "    \n",
    "print(squares)\n",
    "\n",
    "\n",
    "\n",
    "## can make this much simpler as follows\n",
    "\n",
    "\n",
    "squares_new = [ii ** 2 for ii in mylist]\n",
    "print(squares_new)\n",
    "\n",
    "## can include conditions as well\n",
    "\n",
    "odd_squares = [ii ** 2 for ii in mylist if ii % 2 == 1]\n",
    "print(odd_squares)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "supervised\n",
      "True\n",
      "{'linear_regression': 'supervised', 'PCA': 'unsupervised', 'neural_network': 'supervised'}\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "linear_regression is a supervised learning technique\n",
      "PCA is a unsupervised learning technique\n",
      "neural_network is a supervised learning technique\n"
     ]
    }
   ],
   "source": [
    "# dictionaries are kind of like hash tables *** #constant lookup time\n",
    "dict1 = {'linear_regression' : 'supervised', 'PCA': 'unsupervised'} #key : value pairs!\n",
    "print(type(dict1))\n",
    "\n",
    "print(dict1['linear_regression'])\n",
    "\n",
    "dict11 = dict(linear_regression='supervised', PCA= 'unsupervised')\n",
    "print(dict1 == dict11)\n",
    "\n",
    "\n",
    "dict1['neural_network'] = 'supervised'\n",
    "\n",
    "print(dict1)\n",
    "\n",
    "#del dict1['linear_regression']\n",
    "\n",
    "\n",
    "print('\\n\\n\\n')\n",
    "for models in dict1: ##models are keys and method are values\n",
    "    method = dict1[models]\n",
    "    print_str = models + ' is a ' + method + ' learning technique'\n",
    "    print(print_str)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "as done with lists we can also do dictionary comprehensions (will not be covered here )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.19.5\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "(3,) <class 'numpy.ndarray'>\n",
      "2\n",
      "(3, 1)\n"
     ]
    }
   ],
   "source": [
    "a1 = np.array([1,2,3])\n",
    "print(a1.ndim)\n",
    "print(a1.shape, (type(a1)))\n",
    "\n",
    "a2 = np.array([[1], [2], [3]])\n",
    "print(a2.ndim)\n",
    "print(a2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 2) [[0. 0.]\n",
      " [0. 0.]] <class 'numpy.ndarray'>\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "(2,) [0. 0.] <class 'numpy.ndarray'>\n",
      "\n",
      "\n",
      "\n",
      "2 1\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# several \"methods\" are available for numpy arrays -- similar to matlab\n",
    "az1 = np.zeros((2,2))\n",
    "print(az1.shape, az1, type(az1))\n",
    "\n",
    "print('\\n\\n\\n')\n",
    "az2 = np.zeros(2)\n",
    "print(az2.shape, az2, type(az2))\n",
    "\n",
    "print('\\n\\n')\n",
    "print(az1.ndim, az2.ndim)\n",
    "print('\\n\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  [[1. 1.]\n",
      " [1. 1.]]\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "b =  [[5 5]\n",
      " [5 5]]\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "c =  [[1. 0. 0. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [0. 0. 1. 0.]\n",
      " [0. 0. 0. 1.]]\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "d =  [[ 1.2995551  -1.04281782]\n",
      " [ 0.62870946  0.37089952]\n",
      " [-0.77253373  1.7181355 ]]\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = np.ones((2,2)) #array of ones  \n",
    "b = np.full((2,2), 5) #constant array\n",
    "c = np.eye(4) #identity matrix this takes only 1 dimension since it has to generate a square matrix\n",
    "d = np.random.randn(3,2) #random matrix\n",
    "\n",
    "print('a = ', a)\n",
    "print('\\n\\n\\n')\n",
    "\n",
    "print('b = ', b)\n",
    "print('\\n\\n\\n')\n",
    "\n",
    "print('c = ', c)\n",
    "print('\\n\\n\\n')\n",
    "\n",
    "print('d = ', d)\n",
    "print('\\n\\n\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "slicing in the context of numpy arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> (4, 3)\n",
      "[[-1.66742148  0.08035015 -1.75189386]\n",
      " [-2.24556235  0.31494571 -0.77442378]\n",
      " [-1.29731798 -1.22032744 -1.11428796]\n",
      " [ 1.32635782 -0.51601115 -1.74698943]]\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "xc =  [-1.66742148 -2.24556235 -1.29731798  1.32635782]\n",
      "<class 'numpy.ndarray'> (4,)\n",
      "xc1 =  [[-1.66742148]\n",
      " [-2.24556235]\n",
      " [-1.29731798]\n",
      " [ 1.32635782]]\n",
      "<class 'numpy.ndarray'> (4, 1)\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "xr =  [[-1.66742148  0.08035015 -1.75189386]]\n",
      "<class 'numpy.ndarray'> (1, 3)\n"
     ]
    }
   ],
   "source": [
    "X = np.random.randn(4, 3) #2d array\n",
    "print(type(X), X.shape)\n",
    "print(X)\n",
    "print('\\n\\n\\n')\n",
    "\n",
    "\n",
    "#slicing requires 2 dimensions now since ndim is 2\n",
    "#let us extract gien row and given column\n",
    "xc = X[:, 0] #first column\n",
    "print('xc = ', xc)\n",
    "print(type(xc), xc.shape) #notice the shapes!\n",
    "\n",
    "\n",
    "xc1 = X[:, 0:1] ##ignore second element thingy \n",
    "print('xc1 = ', xc1)\n",
    "print(type(xc1), xc1.shape)\n",
    "\n",
    "\n",
    "print('\\n\\n\\n')\n",
    "xr = X[0:1, :] #first row\n",
    "print('xr = ', xr)\n",
    "print(type(xr), xr.shape) #notice the shapes!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.66742148  0.08035015]\n",
      " [-2.24556235  0.31494571]] (2, 2)\n"
     ]
    }
   ],
   "source": [
    "# now let us look at sub-blocks of the 2d-array\n",
    "x1 = X[0:2, 0:2] #observe that the last \"index\" is ignored again, it is non-inclusive\n",
    "print(x1 , x1.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions for you! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.random.randn(5,4)\n",
    "\n",
    "#1. How do i select the elements second and third rows and all but the first column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. how do i select the elements from the last column, but exclude the first and last row elements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before \n",
      " [[-1.45030402  1.01808729  1.07190446]\n",
      " [ 0.02679251 -1.73710764 -0.64764378]\n",
      " [ 0.62599987 -0.86054983  0.05308684]\n",
      " [-1.20605017  1.6191568  -0.03280365]]\n",
      "after \n",
      " [[-1.45030402 10.          1.07190446]\n",
      " [ 0.02679251 -1.73710764 -0.64764378]\n",
      " [ 0.62599987 -0.86054983  0.05308684]\n",
      " [-1.20605017  1.6191568  -0.03280365]]\n"
     ]
    }
   ],
   "source": [
    "#why is it called slicing? \n",
    "X = np.random.randn(4, 3)\n",
    "Y = X[0:2, 1:2]\n",
    "\n",
    "\n",
    "#print(Y)\n",
    "print('before \\n', X)\n",
    "Y[0,0] = 10\n",
    "print('after \\n', X) #observe that the changes made to Y automatically carries over to X. hence slicing! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "other forms of array indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.84994528  0.66526052 -0.135212  ] (3,)\n",
      "[ 0.84994528  0.66526052 -0.135212  ] (3,)\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "before \n",
      " [[ 0.84994528  0.59099431  1.13833105]\n",
      " [ 0.04867159  0.66526052 -0.3532909 ]\n",
      " [ 0.74713977  0.9348436  -0.135212  ]]\n",
      "after \n",
      " [[ 0.84994528  0.59099431  1.13833105]\n",
      " [ 0.04867159  0.66526052 -0.3532909 ]\n",
      " [ 0.74713977  0.9348436  -0.135212  ]]\n"
     ]
    }
   ],
   "source": [
    "X = np.random.randn(3,3)\n",
    "\n",
    "#suppose i only want to access the diagonal elements #integer indexing\n",
    "x1 = X[[0, 1, 2], [0,1,2]]\n",
    "print(x1, x1.shape)\n",
    "\n",
    "#equivalent way of doing this is \n",
    "x2 = np.array([X[0,0], X[1,1], X[2,2]])\n",
    "print(x2, x2.shape)\n",
    "print('\\n\\n\\n')\n",
    "#now what happens if we modify x1 or x2\n",
    "print('before \\n', X)\n",
    "x1[0] = 10\n",
    "x2[1] = 20\n",
    "print('after \\n', X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "simple question for you: How do I select off diagonal elements (the \"other diagonal\") and discuss whether we want changes in one to carry over to the other or not! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "boolean indexing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False  True False]\n",
      " [False False False]\n",
      " [ True False False]] <class 'numpy.ndarray'>\n",
      "[0.82994595 2.07982375] <class 'numpy.ndarray'>\n",
      "[[-0.          0.82994595 -0.        ]\n",
      " [-0.         -0.         -0.        ]\n",
      " [ 2.07982375 -0.         -0.        ]]\n"
     ]
    }
   ],
   "source": [
    "X = np.random.randn(3,3)\n",
    "idx = (X > 0)\n",
    "\n",
    "print(idx ,type(idx))\n",
    "print(X[idx], type(X[idx]))\n",
    "\n",
    "print( X * (X >0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# array operations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]] \n",
      "\n",
      "[[-4. -4.]\n",
      " [-4. -4.]] \n",
      "\n",
      "[[ 5. 12.]\n",
      " [21. 32.]] \n",
      "\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]], dtype=np.float64)\n",
    "b = np.array([[5, 6], [7, 8]], dtype=np.float64)\n",
    "\n",
    "\n",
    "# all the below are element wise operations (for multiplication and \"division\" this is significantly different from matlab!)\n",
    "print(a + b, '\\n') \n",
    "print(a - b, '\\n')\n",
    "print(a * b, '\\n') ##really important!!\n",
    "print(a / b, '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n",
      "219\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "[29 67]\n",
      "[29 67]\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "[[19 22]\n",
      " [43 50]]\n",
      "[[19 22]\n",
      " [43 50]]\n"
     ]
    }
   ],
   "source": [
    "#different ways of doing \"array\" products\n",
    "a = np.array([[1,2],[3,4]])\n",
    "b = np.array([[5,6],[7,8]])\n",
    "\n",
    "x = np.array([9,10])\n",
    "y = np.array([11, 12])\n",
    "\n",
    "#inner products\n",
    "print(x.dot(y)) #<x, y>\n",
    "print(np.dot(x, y))\n",
    "print('\\n\\n\\n')\n",
    "\n",
    "# matrix-vector product\n",
    "print(a.dot(x)) ##check what happens if second argument is 2d array\n",
    "print(np.dot(a, x)) ##probably what you generally do\n",
    "print('\\n\\n\\n')\n",
    "\n",
    "#matrix-matrix product\n",
    "print(a.dot(b))\n",
    "print(np.dot(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6]\n",
      "[2 4 6]\n",
      "(4, 3) (3,)\n",
      "[[ 1  2  3]\n",
      " [11 12 13]\n",
      " [21 22 23]\n",
      " [31 32 33]]\n",
      "(2, 3) (2,)\n",
      "[[ 1  1  1]\n",
      " [12 12 12]]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Broadcasting two arrays together follows these rules:\n",
    "\n",
    "1. If the arrays do not have the same ndim, prepend the shape of the lower ndim array with 1s until both\n",
    "        shapes have the same length.\n",
    "2. The two arrays are said to be compatible in a dimension if they have the same size in the dimension, \n",
    "        or if one of the arrays has size 1 in that dimension.\n",
    "3. The arrays can be broadcast together if they are compatible in all dimensions.\n",
    "4. After broadcasting, each array behaves as if it had shape equal to the elementwise maximum of \n",
    "        shapes of the two input arrays.\n",
    "5. In any dimension where one array had size 1 and the other array had size greater than 1, \n",
    "        the first array behaves as if it were copied along that dimension\n",
    "\n",
    "also refer to : https://numpy.org/doc/stable/user/basics.broadcasting.html for the nitty gritties but \n",
    "    also check http://scipy.github.io/old-wiki/pages/EricsBroadcastingDoc for visual!\n",
    "'''\n",
    "\n",
    "#let us see some examples! -- notice that the trailing (list dimension should be same or one of them should be 1)\n",
    "\n",
    "# eg 1 \n",
    "a = np.array([1, 2, 3])\n",
    "b = 2\n",
    "print(a * b)\n",
    "b2 = np.array([2, 2, 2])\n",
    "print(a * b2) #another way of doing this, but not very efficient\n",
    "#the explanation here is that numpy treats scalars as having shape () so b is broadcasted into (3, ) and then multiplied\n",
    "\n",
    "#eg 2\n",
    "x = np.array([[0, 0, 0], [10, 10, 10], [20, 20, 20], [30, 30, 30]])\n",
    "y = np.array([1, 2, 3])\n",
    "print(x.shape, y.shape)\n",
    "\n",
    "print(x + y)\n",
    "\n",
    "#the explanation here is that b is broadcasted into shape (4, 3) and then added\n",
    "\n",
    "\n",
    "#eg 3 (adding column wise)\n",
    "v = np.array([[0, 0, 0], [10, 10, 10]])\n",
    "w = np.array([1, 2])\n",
    "print(v.shape, w.shape)\n",
    "print((v.T + w).T)\n",
    "\n",
    "#another way of doing this\n",
    "\n",
    "#similar explanation, w is broadcasted into (2, 3) from (3, )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Regression, understanding the homework"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 1)\n",
      "(20, 2)\n",
      "(20, 1)\n",
      "(20, 2)\n",
      "(20, 1)\n"
     ]
    }
   ],
   "source": [
    "m, n = 20, 2\n",
    "\n",
    "noise_var = 1e-8\n",
    "theta_true = np.random.randn(n, 1)\n",
    "print(theta_true.shape)\n",
    "X = np.random.randn(m,n)\n",
    "\n",
    "print(X.shape)\n",
    "noise = np.sqrt(noise_var) * np.random.randn(m, 1)\n",
    "\n",
    "#matrix version of generating data -- avoids for loops. can you tell me why this is equivalent to the way you have done it?\n",
    "y = np.dot(X, theta_true) + noise # another way to do this is y1 = X @ theta_true +noise (only if dimensions are correct!)\n",
    "print(y.shape)\n",
    "\n",
    "\n",
    "X1 = np.zeros((m, n))\n",
    "y1 = np.zeros((m, 1))\n",
    "for ii in range(m):\n",
    "    xtmp = np.random.randn(n,1)\n",
    "    ytmp = np.sum(theta_true * xtmp) + np.sqrt(noise_var) * np.random.randn(1,1)\n",
    "    X1[ii : ii + 1,:] = xtmp.T\n",
    "    y1[ii] = ytmp\n",
    "\n",
    "    \n",
    "print(X1.shape)\n",
    "print(y1.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas (very mild intro)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "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>800\\t0\\t0.3048\\t71.3\\t0.00266337\\t126.201</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1000\\t0\\t0.3048\\t71.3\\t0.00266337\\t125.201</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1250\\t0\\t0.3048\\t71.3\\t0.00266337\\t125.951</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1600\\t0\\t0.3048\\t71.3\\t0.00266337\\t127.591</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2000\\t0\\t0.3048\\t71.3\\t0.00266337\\t127.461</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2500\\t0\\t0.3048\\t71.3\\t0.00266337\\t125.571</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    800\\t0\\t0.3048\\t71.3\\t0.00266337\\t126.201\n",
       "0  1000\\t0\\t0.3048\\t71.3\\t0.00266337\\t125.201\n",
       "1  1250\\t0\\t0.3048\\t71.3\\t0.00266337\\t125.951\n",
       "2  1600\\t0\\t0.3048\\t71.3\\t0.00266337\\t127.591\n",
       "3  2000\\t0\\t0.3048\\t71.3\\t0.00266337\\t127.461\n",
       "4  2500\\t0\\t0.3048\\t71.3\\t0.00266337\\t125.571"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/00291/airfoil_self_noise.dat') \n",
    "##data frames\n",
    "\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this looks like nothing that we hoped it would look like! let's fix this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "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>frequency</th>\n",
       "      <th>angle</th>\n",
       "      <th>length</th>\n",
       "      <th>velocity</th>\n",
       "      <th>displacement</th>\n",
       "      <th>pressure (output)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1498</th>\n",
       "      <td>2500</td>\n",
       "      <td>15.6</td>\n",
       "      <td>0.1016</td>\n",
       "      <td>39.6</td>\n",
       "      <td>0.052849</td>\n",
       "      <td>110.264</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1499</th>\n",
       "      <td>3150</td>\n",
       "      <td>15.6</td>\n",
       "      <td>0.1016</td>\n",
       "      <td>39.6</td>\n",
       "      <td>0.052849</td>\n",
       "      <td>109.254</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1500</th>\n",
       "      <td>4000</td>\n",
       "      <td>15.6</td>\n",
       "      <td>0.1016</td>\n",
       "      <td>39.6</td>\n",
       "      <td>0.052849</td>\n",
       "      <td>106.604</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1501</th>\n",
       "      <td>5000</td>\n",
       "      <td>15.6</td>\n",
       "      <td>0.1016</td>\n",
       "      <td>39.6</td>\n",
       "      <td>0.052849</td>\n",
       "      <td>106.224</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1502</th>\n",
       "      <td>6300</td>\n",
       "      <td>15.6</td>\n",
       "      <td>0.1016</td>\n",
       "      <td>39.6</td>\n",
       "      <td>0.052849</td>\n",
       "      <td>104.204</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      frequency  angle  length  velocity  displacement  pressure (output)\n",
       "1498       2500   15.6  0.1016      39.6      0.052849            110.264\n",
       "1499       3150   15.6  0.1016      39.6      0.052849            109.254\n",
       "1500       4000   15.6  0.1016      39.6      0.052849            106.604\n",
       "1501       5000   15.6  0.1016      39.6      0.052849            106.224\n",
       "1502       6300   15.6  0.1016      39.6      0.052849            104.204"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "Let us give names to the features\n",
    "\n",
    "1. Frequency, in Hertzs.\n",
    "2. Angle of attack, in degrees.\n",
    "3. Chord length, in meters.\n",
    "4. Free-stream velocity, in meters per second.\n",
    "5. Suction side displacement thickness, in meters.\n",
    "'''\n",
    "\n",
    "names_cols = ['frequency', 'angle', 'length', 'velocity', 'displacement', 'pressure (output)']\n",
    "df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/00291/airfoil_self_noise.dat',\n",
    "                header=None, delimiter='\\t', names=names_cols, na_values='?')\n",
    "\n",
    "df.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "okay looks good! let us try to understand the data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1503, 6)\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "##do the dimensions of loaded data match the data set description? \n",
    "print(df.shape)\n",
    "\n",
    "##are there missing values?\n",
    "print(df.isnull().sum())\n",
    "\n",
    "\n",
    "#yes, data matches\n",
    "#great, no missing values. we can proceed with our task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEGCAYAAACQO2mwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2df5AeVZnvv8/8SEImYGCQWUxgAguyAuWiySJeXJmYqMCqcFcvi3eQyI+KJsriXSzFjVWAVsrV9a5k1wrIChKZuQRk1w2XAlFiBlcW8CYICETWWSQYVKKDoBNIIJPn/tHdMz09fbpP/+633++nquvtPt19znm63+6nz3me8xxRVRBCCCFhdFRdAUIIIfWFSoIQQogRKglCCCFGqCQIIYQYoZIghBBipKvqCmTh0EMP1UWLFiU6Z/fu3ejp6SmmQhXRNJmaJg/QPJmaJg/QPJmi5Nm2bdtvVfW1Nvm0tJJYtGgRtm7dmuickZERDAwMFFOhimiaTE2TB2ieTE2TB2ieTFHyiMgO23zY3UQIIcQIlQQhhBAjVBKEEEKMUEkQQggxQiVBCCHECJUEaR2Gh4FFi4CODud3eLjqGhHSeFraBZa0EcPDwMqVwEsvOds7djjbADA4WF29CGk4hbUkROQGEdklIo+F7LtMRFREDnW3RUT+UURGReRREXlzUfVqIsdcfTXQ1QWIOL+rV1ddpfxZs2ZKQXi89JKT3k6wNUVKpsjuphsBnB5MFJEjALwLwDO+5DMAHOsuKwFcU2C9msXq1ViwaRMwMeFsT0wA11xTD0WR5wvtmWeSpTeR4WHgwgudVpSq83vhhVQUpFAKUxKq+gMAz4fs+gqATwHwz3Z0FoBvqsMDAOaLyOFF1a1RXHstxJBeKV73kP+FtnJl+hfakUcmS28il14KvPLK9LRXXnHSCSmIUm0SInIWgGdV9RGRaa+2BQB+4dve6ab9KiSPlXBaG+jr68PIyEiiOhx0xx3Yd8YZ6Nyzx8sQz77vfRj9xCcS5VMXTlMNVRKqinsTXpu8OOyee/AnX/gCOvbvn77jpZew57LL8MCCBZHnj4+Pz7ivh513Ho778pfRuXfvZNrE7Nl48rzzsKsiOZMQJlNSThsbC7/XY2Ol3+s85KkbTZMpN3lUtbAFwCIAj7nrcwE8COA17vbTAA511+8A8DbfeZsBLInLf/HixZqIoSGdEFF1vm2nL6tWJcvLkL/296uKOL9DQ9nzjGLZsnBZvKUKhoZU584110kkNostW7aY8y7z+uaIUaYk1Ohe5yJPzWiaTFHyANiqlu/xMl1g/xjAUQAeEZGnASwE8JCI/BGAZwEc4Tt2oZuWL2vWoMM0p/d112XLO6x75UMfcozJRRkYN2/OP8+shBmY/WTpHhocBJ5+Gti/3/n1ezWtXt18431vb7J0QnKgNCWhqj9R1cNUdZGqLoLTpfRmVf01gNsBnO96OZ0C4EVVndHVlJkdEYEPPcNvWsJejp5C2rEDuOCCcg2MaV8cWY3NUYbkWbOAtWvT1SuK1asdY30djfd5cs45ydIJyYEiXWBvBnA/gONEZKeIXBRx+J0AngIwCuCfARTzdEuoiTcb3hdslAICgFdfjTYw5u3aODbmyCsCLF9ud87wMLBixfTW0IoVyeoS1VIwteKyYmoFZm0d1o0770yWHgZdaElSbPul6rgktklE9ekCqvPnJ8tv1ar4PG36jsP68efOje9zT1LusmVTde7sdNI6O6fbYnp6ws/t6bG/JkNDqrNmmevR3z/zGgbqk7hvuEZ99SZy6e822dMs7DyqGn5vZs1KZdtpWv+9avNkakWbRP154QUgxvNmGnl9qZYxUGzz5vhumd27w881pZuIajH4u6MM9Tnm6quTldfZmSy9VTnkkGTpQehCS1JAJRHkl7+0PzaNHSPMqGrqqorrwkr6ErzGMEYxz26ZNWucrjUT/u4ow1iO123aFH6uqavEC88RxJTeroyNJUsnBFQS4Xh9+d5ywAH59eGGGVVNtpI4G0pWY3uSfGz7saMM13PnTjdcG1ocoVJHDc5bvx5YtWpKaXZ2Otvr18cI1WI8HzY2NSK9FWgHr7RWx7Zfqo5L7jYJm6W72+nDHRrKlk9np129PMLGCHh9+XksSa5PVD92f79Z3uA5hvz3h8lta+OoKbn0d5uug+01yMPm5JKLPCabXh5jllJAmwRtEvngeSl95CPZ8knSCjDF7MmrJeHR02N3XFQ/9tq1TovBz9y5wIYNyaO1+lsPJtopdpPp2tq6FadtsRZFu3iltThUEmkYG0tuzA3Da1rHDZIyGRzz5uWX7Y819WMPDjoPeX+/8/Lp73e2wxSEQe5XDzrIWYkbmAe0V+ymJNc2jPHxZOlFY/rIyfvjh2SCSqJKPNvESSeF7/fSyzIsBmMtpcUbGX3TTc72hz4UbstYtw7o7p6e1t2N0UsucdbjDPfd3cUNzmM/efF0GF4/pnRSCZx0qGqimtZlBhtbtMh5KWqE+6qfqC6K4WGn9eNXbmGTBA0OAvfd51yDiQnH4Hzxxdi1fDmOz1qHtHhuuR6eowFQvSE868RLpvtbVXfTAQeEt8gPOKD8uhAj7aWy582rugYzmZioR7M77qs9iEmZeC+ysNZPcOzH8LBjq/CPk9iwAYfdc49dHV55Jf9Jh0xK+5prqm9ZZBlPMzxsvme2HwZ5k9e4HFIo7aUkqup7jSPOoBj1pdeVY2Mwj5dFnB3Bb2g2vPSO/vrX7cvL23Adp5irjAuVdjyN5/hgor8/fZ2yUDdDOgmlvZREXZk9Ozo96NHi0dMDvOY1xdQpCf5BbnEvLL+h2XDs7Oeec1Zs+qa9/MqOSVTFpE5pR5aHOT54JPGOMpHWhlNGy4axqrJj6ytbx6WScRJ5Lybfdf/4haiYPVXWXTV+/gj/EoxHZRjnMdHR4eyPi43l5Zc29lVYHKuk8ltS6XwSUeelnJNjUp4sYx1yurZGEv4vOE4ifLE6qK5LI5RER0f8w2IaRNXbW62iiKpbmJzBF4fh2GmD6fwvchHVefNmTjoUVwcvuKGfNMEZg0uCSZAKHUzX2xt9Xtw9TMGkPKYBnf7BoiZ6e9PJY0vCwYdUEhxMV09s3E7PPDM8fe9e529fBV5XkK1NYP9+4Prrpzf3Dd0k6u9mOvVUYOFCpyvjyCOdbp7gpENxXVybN88Ml/61r9nVO4oLLpg+wLHoOUPWrg2/Zr//fXS5pkGStoMno8jidLFunTPHiJ9Zs5z0PEhrwyHTaC8lsWwZKnqlmrEJ0meaL6BKQ7yn3JIMZguO1Da8SMTLe3h45ov4vPNmzvZncw2Ds/jlMSYkGMgwbs6QPAi7Zq++Gu3hNGdOsvSyGBwEbrhh+uDAG25IPjKfFEp7jZMYHQ0PHlclK1eao7N61PHLp7/f+TpPWje/a2x/f+j5e/v6MAdwXrimiLL+MQJ1GqFb5MDHKAUU1aKrc/TXwUEqhZrTXi2JusX56ehwulPiwnKYvpSrdBV89dXsc2yvXRs64vqpiy921uNeYt4YgapcOMsm6npEzSlR5Hwb7TKXRxvTXkqibnF+9u93XnJxfbOmL+Wq7BFAsnk3/ATdWoOKLqni27HDbLOpirq5WkbZDbLW0zRnx8AAXU8bQnspiTPPrJ9NYseO+L5Z05dyK35B+20Ba9aEBi5MNJhOJNkcz2Xgn+uiLKLmlIj6qr/wwmz1DJvLY9ky4N//fWbU4rIVRZOemwppLyVx5531s0nYEBUiutWCofkfUEP33+xdu5wVUzecH9X6dSMC+U8/C0Rfj6hWcpTNJo/pS9evB/btc+7Fvn3Aww/bT5Na5GC3rKHVbWiHwXq2vrJ1XBKPk6h68FmUv33coB+TT37VdU+6+MdKGPzYX+7rc/bbjmWwGavhDdDzKEtel0In6Qle1yA21ychkfLYljM05Exg5d8fNaFVGoocy5J2EGdJcJxEGupmkwCc5rlN4DYv/LZ/jEArfrXceuvUuuFLb9JwbdONNGeOk0/QphNk6dLp2zatlLoRdT381zVI2HWuA6Z5Uop2I86LLAEXW4j2UhJ1tEmsXGnuLonrRsk6O56J3t4p20je+D10BgeBFSum92evWIFd3sA3m26kPXucX425s6Oj07dNzgKmOFp1II2bKzA1WVHdKNo1N2ycTZ4DHttksF57KYm62SS6uhwXWFMLx58e1vdZVEjlF16YWi8yvHpcqHDblt+aNebxFB7BF+zgIHDRRdMV1EUX5RtVN2+ytISLHIuwfLnzUeEtJsq2n4WNs8lzwGObRLFtLyVRNwPnvn3OCy7OwOaf69n7IjK5HubBxMRUOXHTh2YhLlR42DiKMGy+3IIvWIOCqvVcBlGuvjbdZ0WMaVi+3H68TF4zH9pSdEvF1HqNa9W2GO2lJKIGHFXFM8/Ez11s6vssg7wfbH+8oLhQ4YDdV1ncSy7Mo6XKa5qWKJvEOefEnz8wkCzdhiQDKul62pK0l5KoI94Xbphh2iNrC6hOzV9/vKC4AH9h4yiCdHREu3i6do4Z3S1ltCrzvu5RLaZvfjP+/KBdJi49T/J2Pa0DcZESGkJhSkJEbhCRXSLymC/t70XkpyLyqIh8W0Tm+/Z9RkRGReRJEXl3IZWKGnBUBbYPjqkv2mt5RNHZCbzhDcnrFkfaCKL+pn5cgD+bF3lcS8frRgoaK03XtLc33lPKlry7HaLudVw32fCwWckUpTADDgmNi9Fkar3ZtOpaiCJbEjcCOD2Q9j0AJ6rqGwH8J4DPAICIHA/gXAAnuOesF5H8g7/UzQXW36UUNSjnmGPCz+/piX8RTUwA27enr2N398wv/u5u4Pzz0xki/XnFtSRsugdt+tPD3BJNdqB166aPfq9TDKK0SsezaZko6rnw23uuu26moi4yhHkZmLr/6hYBICOFKQlV/QGA5wNp31XVfe7mAwAWuutnAdioqntV9ecARgGcnHul1q7FRJ1cHP0KIsww7T1UIyPh5z/xhF05aV4unm3k4otnvihFgJtuSmev8Lce4loSnnurbX5RhHk3RdmBkuZfZ6LmHc/aDWSrRCcmZrps1zWEuS1pXddbjCr9/S4EcIu7vgCO0vDY6abNQERWAlgJAH19fRgxvUDDWLAAB3384zh+aAizn3uuUndYBbD9s5/FruXLccpll2FOiBF1z2WX4YEFC3DaxERoXRUoRIZ9c+bgh3fdBQA45dxzMSdkwJO+8kqqsvf09eEB9569vaMDHSGKRjs6cO/ICE7bvTu2jD19fVb3cs9hh02W63HY9u04es8ezAawd88ePLV9O/DZz+K4L38ZnXv3Rua331D3aXIAuNctc3x8PNl/NYT/dtBBmPX738eWFeS0HTuM/59n3/lOjC5YYP4QMeDJc8x73oMFmzZNy9/0v9Tdu6fV8bSxsfDjxsaMsiThNFM9EH6tkt6jt82eja6QD5l9s2fjhznUPyt5/OcAwGpYdtoFwCIAj4WkrwHwbQDibn8VwHm+/dcD+EBc/onDcviHqpcZisK0eCEI4sIYmKaILGrxh7DIO5SJP3yE4ZjJ6Uvj8urqir9+YeWqmkMqmKbUDB63apVqd7f1dcwlLIfNfyWMOFlShJGYJs+yZfb330+WqU9tSDg9auJ7lOZelEjLhuUQkQ8DeA+AQbeyAPAsgCN8hy1005qNF4Igzn/d1J+8bFkx9fJ/IZv6q9N67vjDRxhcIvf29TkrcTaPffuA++5LXi5gdoGN86H3jLCnnhp/DYKhQOpI1jASw8PA/fenOzfL1Kc2rFs38z/U0ZHf9KhtQqlKQkROB/ApAO9TVf8TejuAc0VktogcBeBYAD8qs26VMTYW/7CceurMkcBdXcDrX19MnfxKy2Tgfcc70uXtfwnHTTpkY/O47jq7UeHBl3/a0Amet1RY3KEgebuWFhUTKEsfepS9I44yQnmHPTetzurVjhwizu/q1YUWV6QL7M0A7gdwnIjsFJGL4HQrHQjgeyLysIhcCwCq+jiAWwE8AeA7AD6mqsVaDOvkyxzn5bFmjfPV7GffPuBrXyumPv6Wi8nAm9cLMGrSIZuXxcREunhLUa2AuGB4Ni0OIH8DZlEG0SzB/5LUKfjMGT4SchtPYZivpKUD8K1e7Ux37Pccu+aaQhVFkd5NH1TVw1W1W1UXqur1qnqMqh6hqie5y0d9x69V1T9W1eNU9a6i6jXJSScVXoQVPT3Ayy+H7/PSTQ9iEWEOli1z5geII+0Ly/9yjpt0yCZ6aWen3Qs7qIgnezpD8CvFLOTtWhrlEpzFbdT0/7PBVsbu7vBunqwzE0ZRtPdRFYPpTB+GRX0wop1HXNfA+2AS08veSy9zfMfDD0/fNrnnph1w5n85x006FIwSG8bAgJ0bZlq3SlPevb3xCqzMaVWj5Iuz7WT52DB1R65aNb31+Y1vzHQvLvpL3yZwZhbWrZv5/+jsLNbmEfeuKID2VRJ18X/fvTvecG16EJN8Pdp2yYyNTR/0ZDLwxriIWmH4Mn71wAOdlWAQvjBGR+3uZXC0velrr6dnulIMy9sbdBenwPIeVBUVMSBqX9wLJMuAQVN35Kmnxp9b9Je+SUnnqbyDLdKoFmqL0r5Kok4jaU3eS166Yd4FqyamN+dwEqXoD6Wcdz+4/+VsGCzX4X1d2hhFn3nGznYR/Ho0hU4QCS+zs3P6SxCIV2B5X7uoL+CofXHXJ0uAvzDuuy96cKhH0V/6RY+IvvTSmQp4//7WmTTJFltf2ToumcZJ2E6NWcaiOtPXfNmyqUoPDc30ye/utvebt5m+Ms9zTYtXZw/DcZPjJGzGaHhTUgbHPESVm0YukeTn9/fP/N9lwfSf7eiIHusQd3189bRlUp6w/6ZtOVH/6zww/X+C9zIoky02z0/eJCizZcdJ1Ib1651+06pbFL294b7m998/9eUVNXmKqduko2MqDlSWmbJMXV1pbBJh/dJRxH1ReiEl/F0eYYQZQ5N+5fuv5/Bw/PlFRD01fQHPnRt9Xb2WqIksLZ6w/2aScoo0XJsM/XWcMqDO2GqTOi6ZWhJBenqSfVnmsXR2Tk3UHvXlFZXH0JBOxI3ITjpq2j/iWjV8Mvk0I7GDGEbE7j3oIGd/VGvPNKl93LWMO87mfxA3Mruzc8YI71xaElHXvKqWRJL7b3sPUtQnlKJHXCfMPxc6OuyeWWVLIn+qmJHMa8VkMeANDuKnl18eHbVUNVm9gv2sYXNdJP0aC2vxGLxDRi+5xFk3fTn398+cc8PDdt5hk/HS5kvWs1mYvJtM4cmzEtWyivIIirLt5DkuIYqwllXRhmuTMT+vKQNM86QX6d1kGsVf4Oh+Kokq8dz9Mhrwdi1fPvUSz8MVLu8uOJOPfFhZ/u00E83bTtFpUkDj4+a8/Tz/fHQXV9ZwF2FEvcyjXqxR+4qckCouwm7Rhuui8x8cnB5Wvr/f2S5y3owKJo6ikvCoagT2M8/Ez3GdBNMXfpK5H9K4lAbxewOZbBFxg+nSzMlsGw8oi50GcF40XgvL9KLN27tpcND8P03r+ZR1XEKUK3Ecef7vq8i/CqoIT27bL1XHJVebxNCQE5U1aT971sXrf121aioqZrBPO6aff5pMNlFM4xaD98c0bLx74jD0se/3yk+Tt21kUdNxItH998DMyKkWfeu52CRUzdFrs9gkbO53gMRegiYPrDB7V54kyD/xPSraOyuMBHaQvGwSVgfVdclVSahO/0P19pqNRHkt3sMd9+AnURJ5hfaOI+7FE2JIm4Hh5fpyX5+zP00oaVuZoo4LvlhWrQp/0fidDoLXPfDizk1J+MtN8mKNcjZIYWidlCeJK3FPT+JyyqQlDNdUEhUrCT95jg/wPyRhD3cW76agTHnV24a08xv4zw9Rjo+vWWMldyhZWxK2cxmE1d17CYe8uHNVEmnJ8aU2KU/Sj5Iaw3ES4QttEiaK6OObM2eml1BUWV56kpDKpn7YJDYX22OzGugMIR12LV/u7E8TStrWJpF1LoMwjyHVaM+rKhkeNgdCzOLtU7d545tOGjtdRqgkTBTx5zc9jHFeGEkMcKZYOuvWzcyju3tmfP2kLnxZI2GGudd6pDE82iqWrPU2KfYdO6YG3NUFL0ijiSz/9TKDGKahyLkXTM4gSZxEklL0RE1h2DY56rgU2t2UdsBY1GIaJGRjjIzoh04kUzCPrIbDAox30+RJWj9bw27Wrpe4br0ibRJJiapr1ulLkzhKzJuXq1ixmIzqwalsXVqiuynBAETaJLRgJaGaXSkkeRgzvKwr7+/O2UMlszw29UkY1ye0jDgvqCK8m9KQdqR2BKnnii+TomM3FT1iPIwEH2W0SZRBXtModnaGDybyE9XtUnfqVneb+mQdaBUXLwoo1nc9CSaZ+vurv1dFoposPSllhCIPIyzybIFQSURhMzOaDfv3N/thbEXyGGjlKSOToqiLUbfIQWV1mga4bG69NVl6Hlx6abgTRoHhyakkorD5WrShLi8LMoXJwJ9Gmdd9ZG+esgYJi19kouyIy/PmJUtPislbzGY63RYqk0oiDu9rUTWdsqjTy4JMJ69usiJfwnlRVJdgWPyiZcvCj43ysCqCa6+d6b3X1eWkE2uoJJJg0/3U21vvlwUphrrZZcokKPs990yfq6Wz09lev778et144/Tn8cYb87s3Wd2o02CKiZVkKuOEdMUfQibx/lxr1jj+8CLTjWDe3Mft9IIgJIz168tXCmEMDhb3PJ5zDnDNNeHpDYItiaT4u59uuomtBkLalaLn0A7DNO9NgfPhsCWRhSK/Uggh9aaKsN0VwJYEIYSkoehJjWoClQQhhKShCtfnCozlVBKEEJKGKlyfK5hXuzAlISI3iMguEXnMl3aIiHxPRH7m/h7spouI/KOIjIrIoyLy5qLqRQghuVG263MF82oX2ZK4EcDpgbTLAWxW1WMBbHa3AeAMAMe6y0oAIX5lhBBCylZMhSkJVf0BgOAECmcB2OCubwBwti/9m26AwgcAzBeRw4uqGyGEEDtE84qIGJa5yCIAd6jqie72C6o6310XAL9T1fkicgeAv1PVH7r7NgP4tKpuDclzJZzWBvr6+hZv3LgxUZ3Gx8cxL6/YLTWhaTI1TR6geTI1TR6geTJFybN06dJtqrrEJp/KxkmoqopIYg2lqtcBuA4AlixZogMDA4nOHxkZQdJz6k7TZGqaPEDzZGqaPEDzZMpLnrK9m57zupHc311u+rMAjvAdt9BNI4QQUiFlK4nbAaxw11cA2ORLP9/1cjoFwIuq+quS60YIISRAYd1NInIzgAEAh4rITgBXAPg7ALeKyEUAdgDwImHdCeBMAKMAXgJwQVH1IoQQYk9hSkJVP2jYNSPYvDvn6seKqgshhJB0cMQ1IYQQI1QShBBCjFBJEEIIMUIlQQghxAiVBCGEECNWSkJELrVJI4QQ0ixsWxIrQtI+nGM9CCGE1JDIcRIi8kEA/xPAUSJyu2/XgZgZ4ZUQQkjDiBtM9x8AfgXgUAD/25f+BwCPFlUpQggh9SBSSajqDjjhM95aTnUIIYTUCauwHCLyBwBeWO9ZALoB7FbVg4qqGCGEkOqxUhKqeqC37k4WdBaAU4qqFCGEkHqQeJyEO8XovwF4dwH1IYQQUiNsu5v+0rfZAWAJgD2F1IgQQkhtsA0V/l7f+j4AT8PpciKEENJgbG0SnASIEELaENuwHEeLyP8Vkd+IyC4R2SQiRxddOUIIIdVia7j+PwBuBXA4gNcB+BaAm4uqFCGEkHpgqyTmqupNqrrPXYYAzCmyYoQQQqrH1nB9l4hcDmAjnEF1fwXgThE5BABUlXGcCCGkgdgqiXPc348E0s+FozRonyCEkAZiqyTeoKrTxkWIyJxgGiGEkGZha5P4D8s0QgghDSJuPok/ArAAwAEi8iYA4u46CMDcgutGCCGkYuK6m94NZwa6hQD+wZf+BwB/W1CdCCGE1IS4+SQ2ANggIu9X1X8pqU6EEEJqgq3h+kQROSGYqKqfy7k+hBBCaoSt4XocwG53mQBwBoBFaQsVkf8lIo+LyGMicrOIzBGRo0TkQREZFZFbRGRW2vwJIYTkg22AP//81hCRLwO4O02BIrIAwF8DOF5VXxaRW+GMtzgTwFdUdaOIXAvgIgDXpCmDEEJIPiSedMhlLhxjdlq64HhMdbl5/QrAOwDc5u7fAODsDPkTQgjJAdtJh36CqTmuOwAcBuDzaQpU1WfdlsgzAF4G8F0A2wC8oKr73MN2wnG9JYQQUiGiqvEHifQDOBjAnwOYD+BOVd2WqkCRgwH8C5z4Ty/AiSh7G4ArVfUY95gjANylqieGnL8SwEoA6OvrW7xx48ZE5Y+Pj2PevHlpql5bmiZT0+QBmidT0+QBmidTlDxLly7dpqpLrDJS1dgFjg3hJwCuAvA5AI8CuMTm3JC8/geA633b58OxPfwWQJeb9lYAd8fltXjxYk3Kli1bEp9Td5omU9PkUW2eTE2TR7V5MkXJA2CrWr6zbV1gLwZwiqruBgAR+SKA+wH8k+X5fp4BcIqIzIXT3bQMwFYAWwB8AE6k2RUANqXImxBCSI7YGq4FjuurxwSmQnQkQlUfhNO99BCc1kkHgOsAfBrA34jIKIBeANenyZ8QQkh+2LYkvgHgQRH5trt9NjK8xFX1CgBXBJKfAnBy2jwJIYTkj+04iX8QkREAb3OTLlDVHxdWK0IIIbXAtiUBVX0IThcRIYSQNiHtYDpCCCFtAJUEIYQQI1QShBBCjFBJEEIIMUIlQQghxEjbKgm5SiZ/g+th2/40/2/UecHjktQrjTw259rmn6QeaetcZXl1KicNtve7VShaliZdq7JpWyVBCCEkHioJQgghRqxChdeVJUuW6NatW62Pr0OTU6+Yeb2j6hV2vM15/nNt809Sj7R1TptHHuXlXackjIyMYGBgIPX5gP39LoOi5clDlqT55yFTnYiSR0TyDRVe1yVLqHBcicnf4HrYtj/N/xt1XvA4G5Ie78nkLzOP/JPUI02do/KIC9mcR3k25FlO3mGobe93URQhT5HY5M9Q4eELu5sIIYQYoZIghBBixDrAX9Pw+iT9fZPBfsqwfsuk5yXtW03bF2t7Xt7HJZWHSI8AAA0tSURBVD22LuXVqZw01LluaShanqZdrzJhS4IQQogRKglCCCFGqCQIIYQYoZIghBBihEqCEEKIESoJQgghRqgkCCGEGKGSIIQQYoRKghBCiBEqCUIIIUaoJAghhBihkiCEEGKESoIQQoiRSpSEiMwXkdtE5Kcisl1E3ioih4jI90TkZ+7vwVXUjRBCyBRVtSTWAfiOqv4JgD8FsB3A5QA2q+qxADa724QQQiqkdCUhIq8B8HYA1wOAqr6iqi8AOAvABvewDQDOLrtuhBBCpiPOdKclFihyEoDrADwBpxWxDcClAJ5V1fnuMQLgd9524PyVAFYCQF9f3+KNGzcmKn98fBzz5s3LJEPdaJpMTZMHaJ5MTZMHaJ5MUfIsXbp0m6ouscrIdjLsvBYASwDsA/AWd3sdgM8DeCFw3O/i8lq8eHHSucEbN9m5avNkapo8qs2TqWnyqDZPpih5AGxVy3d2FTaJnQB2quqD7vZtAN4M4DkRORwA3N9dFdSNEEKIj9KVhKr+GsAvROQ4N2kZnK6n2wGscNNWANhUdt0IIYRMp6uici8BMCwiswA8BeACOArrVhG5CMAOAOdUVDdCCCEulbjAqurDqrpEVd+oqmer6u9UdUxVl6nqsaq6XFWfL7IOcpVM/vrX/b+mdX9aMM/gvrC0sii73CLLq+oa1q0OedEkWUixcMQ1IYQQI1QShBBCjFRlk6iEySb2vYFtzOxKStvlZNrnT9MrihubEtbdVWS5RZZXtix1rUNeNEkWUh5tpST0CsXIyAgGBgYgVwn0Cp18ULx1/y+A0HV/mh9/XlFpRRIsu+hyiyyvbFnqWoe8aJIspDzY3UQIIcQIlQQhhBAjbdXd5Mdravub3FFppv1hecallUXZZRdZXh26RupQh7xokiykWNiSIIQQYoRKghBCiBEqCUIIIUaoJAghhBihkiCEEGKESoIQQogRKglCCCFGqCQIIYQYoZIghBBihEqCEEKIESoJQgghRqgkCCGEGKGSIIQQYoRKghBCiBEqCUIIIUaoJAghhBihkiCEEGKESoIQQogRKglCCCFGqCQIIYQYqUxJiEiniPxYRO5wt48SkQdFZFREbhGRWVXVjRBCiEOVLYlLAWz3bX8RwFdU9RgAvwNwUdEVkKtkcvGn+X/9x8WdY9oflkeWOmclqv55lp1HXZOSRq48y6w7Rda1la5D3lT9Xy+SSpSEiCwE8BcAvu5uC4B3ALjNPWQDgLOrqBshhJApuioq92oAnwJwoLvdC+AFVd3nbu8EsCDsRBFZCWAlAPT19WFkZCRRwePj46Hn+NO89eBxUdtxecblnYTguSaZkuRje37SctLUK608YWVmySdtmWFklSlP8qiHzXPUauT5vyuLqDLz+s+JqmbOJFGBIu8BcKaqrhaRAQCfBPBhAA+4XU0QkSMA3KWqJ0bltWTJEt26dWuy8mvYJNYrou9BVJ31CsXIyAgGBgZS5xFVn7iyk5QTJ6eHjTy2ZaYpP2uZYeUklSlP8rgnQTx5isi7KvL83xUle5Iyo+QRkW2qusSqUFUtdQHwBTgthacB/BrASwCGAfwWQJd7zFsB3B2X1+LFizUpW7ZsmVzHlZhc/Gn+X/9xceeY9oflkZawc/0y2eZhqn/SsvM83iOpPKYys1zntGWayCJTnuR1TcLkKet6F0Ve/7uyiCszSh4AW9XynV26TUJVP6OqC1V1EYBzAXxfVQcBbAHwAfewFQA2lV03Qggh06nTOIlPA/gbERmFY6O4vuL6EEJI21OV4RoAoKojAEbc9acAnFxq+SH9hl6af59p3Xa/7TE25NHXGczDNs+kZVfRJ53XdU5bZt0psq6tdB3ypur/epHUqSVBCCGkZlBJEEIIMUIlQQghxAiVBCGEECNUEoQQQoxQSRBCCDHS1krCFPHVtB4XLTZsXxVRSdPQztFB86xf3WUtG16P1qetlQQhhJBoqCQIIYQYqXTEdRUsvXcpcO/UdpIuJ9O+qC6nqPWqR6hGyZa1bkXmnQd51q/uspYNr0ezaDslseW0LZPhc+UqgV6hk7/+tLB1ADP2+Y/x8O8LO6cuBEOC51m3IvPOgzzrV3dZy4bXo1mwu4kQQogRKglCCCFG2q67yU+SiK+myKm2kWRNx9aFdo4OWlQ3G+H1aAJsSRBCCDFCJUEIIcQIlQQhhBAjVBKEEEKMUEkQQggxIqqt630gIr8BsCPhaYcC+G0B1amSpsnUNHmA5snUNHmA5skUJU+/qr7WJpOWVhJpEJGtqrqk6nrkSdNkapo8QPNkapo8QPNkyksedjcRQggxQiVBCCHESDsqieuqrkABNE2mpskDNE+mpskDNE+mXORpO5sEIYQQe9qxJUEIIcQSKglCCCFGGqUkROR0EXlSREZF5PKQ/bNF5BZ3/4Missi37zNu+pMi8u4y620irTwi0isiW0RkXES+Wna9o8gg0ztFZJuI/MT9fUfZdQ8jgzwni8jD7vKIiPz3sutuIstz5O4/0v3vfbKsOkeR4R4tEpGXfffp2rLrbiLju+6NInK/iDzuPk9zIgtT1UYsADoB/BeAowHMAvAIgOMDx6wGcK27fi6AW9z1493jZwM4ys2ns4Xl6QHwNgAfBfDVqu9NTjK9CcDr3PUTATzb4vLMBdDlrh8OYJe33aoy+fbfBuBbAD7ZyvIAWATgsaplyFmmLgCPAvhTd7s37l3XpJbEyQBGVfUpVX0FwEYAZwWOOQvABnf9NgDLRETc9I2quldVfw5g1M2vSlLLo6q7VfWHAPaUV10rssj0Y1X9pZv+OIADRGR2KbU2k0Wel1R1n5s+B0BdPEiyPEcQkbMB/BzOPaoDmeSpKVlkeheAR1X1EQBQ1TFVnYgqrElKYgGAX/i2d7ppoce4D+iLcDSpzbllk0WeupKXTO8H8JCq7i2onrZkkkdE3iIijwP4CYCP+pRGlaSWSUTmAfg0gKtKqKctWf9zR4nIj0XkXhH586Ira0kWmV4PQEXkbhF5SEQ+FVdYW89MR1oPETkBwBfhfBG1NKr6IIATROQNADaIyF2qWrfWXxKuBPAVVR2v94e4Nb8CcKSqjonIYgD/JiInqOrvq65YBrrgdEX/GYCXAGwWkW2qutl0QpNaEs8COMK3vdBNCz1GRLoAvAbAmOW5ZZNFnrqSSSYRWQjg2wDOV9X/Kry28eRyj1R1O4BxOLaWqski01sAfElEngbwCQB/KyIfL7rCMaSWx+1+HgMAVd0Gxw7w+sJrHE+We7QTwA9U9beq+hKAOwG8ObK0qo0wORpzugA8Bcfw7BlzTggc8zFMN+bc6q6fgOmG66dQveE6tTy+/R9GvQzXWe7RfPf4v6xajpzkOQpThut+AL8EcGgryxQ45krUw3Cd5R691nsPwDESPwvgkBaX6WAAD8F1nABwD4C/iCyvaoFzvnhnAvhPOBp/jZv2OQDvc9fnwPG6GAXwIwBH+85d4573JIAzqpYlB3meBvA8nC/UnQh4P7SaTAA+C2A3gId9y2EtLM+H4Bh3H3Yf2rOrliWP/50vjytRAyWR8R69P3CP3lu1LHncIwDnuXI9BuBLcWUxLAchhBAjTbJJEEIIyRkqCUIIIUaoJAghhBihkiCEEGKESoIQQogRKgnStojIX4vIdhEZrrouhNQVusCStkVEfgpguaru9KV1aT1iKBFSC9iSIG2JOzfA0QDuEpEXReQmEbkPwE0i0ikify8i/09EHhWRj7jniIh81Y3jf4+I3CkiH3D3PS0ih7rrS0RkxF3vEZEbRORHbqC4s9z0D4vIv4rId0TkZyLyJV/dTneDrz0iIptFpMM95rXu/g53noDXlnnNSHvCAH+kLVHVj4rI6QCWAvg4gPcCeJuqviwiKwG8qKp/5oYjv09EvgtnTovj4Mw/0gfgCQA3xBS1BsD3VfVCEZkP4Ecico+77yQ3z70AnhSRf4IT3v2fAbxdVX8uIoeo6n4RGQIwCOBqAMsBPKKqv8nrehBigkqCEIfbVfVld/1dAN7otRLgBEc7FsDbAdysTvz9X4rI9y3yfReA98nULG1zABzprm9W1RcBQESegBPD6WA4Adh+DgCq+rx77A0ANsFREhcC+EY6MQlJBpUEIQ67fesC4BJVvdt/gIicGXH+Pkx13/qngxQA71fVJwN5vQVOC8JjAhHPo6r+QkSeE2fa1pPhtCoIKRzaJAiZyd0AVolINwCIyOtFpAfADwD8lWuzOBxOV5XH0wAWu+vvD+R1iW/mtjfFlP0AgLeLyFHu8Yf49n0dwBCAb2nMbGKE5AWVBCEz+Toce8NDIvIYgK/B+cr/NoCfufu+CeB+3zlXAVgnIlvhtAo8Pg+gG8Cj7ix0n48q2LUzrATwryLyCIBbfLtvBzAP7GoiJUIXWEJSIiI3ArhDVW8rqbwlcGZ+q8s0mqQNoE2CkBZARC4HsAq0RZCSYUuCEEKIEdokCCGEGKGSIIQQYoRKghBCiBEqCUIIIUaoJAghhBj5/zqPmnenkjzQAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#let us try to see the data -- very important to do this before you run ANY algorithm\n",
    "#this gives us some intuition about correlations/nature of data\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "x = np.array(df['displacement'])\n",
    "y = np.array(df['pressure (output)'])\n",
    "z = np.array(df['velocity'])\n",
    "\n",
    "plt.plot(x, y, 'ro', x,z, 'g+')\n",
    "plt.grid()\n",
    "plt.xlabel('frequency')\n",
    "plt.ylabel('output')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1503, 6) <class 'numpy.ndarray'>\n",
      "(1503, 5) (1503,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\na. make sure to use the correct slicing (based on how you write later part of code) !!\\nb. now all we need to do is run the older linear regression codes\\nc. since we have lot of data, better to run gradient descent. also lot of \"tricks\" can be conjured to \\n    improve performance (we will talk about it next time)\\n'"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#converting dataframe to numpy array\n",
    "\n",
    "A = df.to_numpy()\n",
    "print(A.shape, type(A))\n",
    "\n",
    "#output (y) is the last column of A\n",
    "#the first 5 columns (features are the matrix X)\n",
    "\n",
    "X = A[:, 0: 5]\n",
    "Y = A[:, -1]\n",
    "print(X.shape, Y.shape)\n",
    "\n",
    "\"\"\"\n",
    "a. make sure to use the correct slicing (based on how you write later part of code) !!\n",
    "b. now all we need to do is run the older linear regression codes\n",
    "c. since we have lot of data, better to run gradient descent. also lot of \"tricks\" can be conjured to \n",
    "    improve performance (we will talk about it next time)\n",
    "\"\"\""
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}