explanations/intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Welcome!\n",
    "\n",
    "Welcome to the Zero to GPT course!  This course will take you from no deep learning knowledge to being able to train your own GPT model.\n",
    "\n",
    "At a high level, GPT works by predicting what words should come after your prompt.  Here's an example of some text you can feed into GPT, and a response:\n",
    "\n",
    "![gpt text](images/intro/gpt_text.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "GPT models are types of deep learning models.  Deep learning is a subfield of machine learning, which is a subfield of AI.  In deep learning, we train a neural network composed of many layers to transform an input into an output.\n",
    "\n",
    "Neural networks can't understand text directly, so GPT has to convert your prompt to numbers, make predictions, then convert the predictions back to text.  The process works like this at a very high level:\n",
    "\n",
    "![gpt steps](images/intro/gpt_steps.svg)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "\n",
    "The key part of GPT is the prediction step, where the network predicts what words will come next.  To do this, the network uses its parameters.  You can think of parameters like memory.  This memory has been trained on a lot of data (gigabytes or terabytes).  Parameters enable neural networks to make accurate predictions about what should come after your prompt.\n",
    "\n",
    "The smallest GPT models have around 100M parameters, and the largest have 176B.  They use parameters to transform your input to predictions - usually by adding the parameters to your input, or multiplying your input by the parameters.\n",
    "\n",
    "By the end of this course, you'll understand how to train deep neural networks that work like GPT.  This course is split up into three parts:\n",
    "\n",
    "1. Understanding deep learning - how to create and train deep neural networks, including gradient descent and backpropagation.\n",
    "2. Deep learning for NLP - deep learning architectures to work with text, including RNNs, encoder/decoders, attention, and transformers.\n",
    "3. Scaling up models - putting together the building blocks to train a model with a large number of parameters.\n",
    "\n",
    "Check out the [README](https://github.com/VikParuchuri/zero_to_gpt/blob/master/README.md) for a full lesson overview."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Teaching method\n",
    "\n",
    "This course will get you ready to do meaningful work with deep learning.  We'll balance theory and practical application.  Without theory, you won't understand how to apply deep learning in the real world.  But theory shouldn't overwhelm - it should aid you in actually doing the work.\n",
    "\n",
    "In each lesson, you'll learn the theory behind what you're doing, and code complete implementations that solve problems.  For example, in the dense neural networks lesson, you'll learn the theory - backpropagation, why nonlinearities are useful, and how multiple layers work.  Then you'll code a complete neural network using NumPy that predicts the weather.\n",
    "\n",
    "I'll explain concepts in multiple ways - diagrams, text, code, and video.  Deep learning is complicated, and it can take multiple explanations before a concept clicks.\n",
    "\n",
    "### What this course is not\n",
    "\n",
    "- This is not a course where you'll just import PyTorch and type code without understanding what you're doing.  We'll build up your knowledge step by step.\n",
    "- This is not a mathematically rigorous course.  We'll include the math, but we'll focus on building intuition and understanding first.  For a mathematically rigorous resource, I recommend the [deep learning book](https://www.deeplearningbook.org/)."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Who am I?\n",
    "\n",
    "My name is Vik Paruchuri.  I've won ML competitions, worked as an ML engineer, and started Dataquest, which has taught data skills to 1M+ people.  Before all that, I was a self-taught programmer who dreamed of predicting the stock market.\n",
    "\n",
    "This course is for anyone dreaming of building their own deep learning models."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Prerequisites\n",
    "\n",
    "This course is designed to be accessible.  You'll need to understand Python to take this course, including for loops, functions, and classes.  The first part of [this Dataquest path](https://www.dataquest.io/path/data-scientist/) will teach you what you need.\n",
    "\n",
    "Experience with [NumPy](https://www.dataquest.io/course/pandas-fundamentals) and linear algebra will also help.  If you don't have any experience, we'll cover some basics in the rest of this lesson.\n",
    "\n",
    "If you already know NumPy, feel free to skip to the [next lesson](https://github.com/VikParuchuri/zero_to_gpt/blob/master/explanations/linreg.ipynb)."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy fundamentals\n",
    "\n",
    "NumPy is a Python package that enables us to work with arrays of data more efficiently.\n",
    "\n",
    "To understand why we need NumPy, let's start with one of the fundamental machine learning algorithms, linear regression.  In linear regression, we make a prediction using the equation $\\hat{y} = wx + b$.  In deep learning, we call $w$ the weight, and $b$ the bias.\n",
    "\n",
    "Let's say that we want to predict tomorrow's temperature using three data points from today - today's max temperature, today's min temperature, and how much it rained today.\n",
    "\n",
    "Let's read in our dataset using pandas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "            tmax  tmin  rain  tmax_tomorrow\n1970-01-01  60.0  35.0   0.0           52.0\n1970-01-02  52.0  39.0   0.0           52.0\n1970-01-03  52.0  35.0   0.0           53.0\n1970-01-04  53.0  36.0   0.0           52.0\n1970-01-05  52.0  35.0   0.0           50.0",
      "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>tmax</th>\n      <th>tmin</th>\n      <th>rain</th>\n      <th>tmax_tomorrow</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>1970-01-01</th>\n      <td>60.0</td>\n      <td>35.0</td>\n      <td>0.0</td>\n      <td>52.0</td>\n    </tr>\n    <tr>\n      <th>1970-01-02</th>\n      <td>52.0</td>\n      <td>39.0</td>\n      <td>0.0</td>\n      <td>52.0</td>\n    </tr>\n    <tr>\n      <th>1970-01-03</th>\n      <td>52.0</td>\n      <td>35.0</td>\n      <td>0.0</td>\n      <td>53.0</td>\n    </tr>\n    <tr>\n      <th>1970-01-04</th>\n      <td>53.0</td>\n      <td>36.0</td>\n      <td>0.0</td>\n      <td>52.0</td>\n    </tr>\n    <tr>\n      <th>1970-01-05</th>\n      <td>52.0</td>\n      <td>35.0</td>\n      <td>0.0</td>\n      <td>50.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Read in the data\n",
    "data = pd.read_csv(\"../data/clean_weather.csv\", index_col=0)\n",
    "# Fill in any missing values in the data with past values\n",
    "data = data.ffill()\n",
    "\n",
    "# Show the first 5 rows of the data\n",
    "data.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the table above, tomorrow's temperature is `tmax_tomorrow`, today's max temperature is `tmax`, today's min temperature is `tmin`, and how much it rained today is `rain`.\n",
    "\n",
    "We have data from `1970` to the present.  With linear regression, we can extend our equation to multiple predictors like this:\n",
    "\n",
    "$$\\hat{y} = w_{1}x_{1} + w_{2}x_{2} + w_{3}x_{3} + b$$\n",
    "\n",
    "So to get a prediction for tomorrow's temperature $\\hat{y}$, we can take a value called $w_{1}$, and multiply it by `tmax`, then take $w_{2}$ and multiply it by `tmin`, then take $w_{3}$ and multiply it by `rain`.  We'd then add in $b$.  Here's how that could look:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "62.5"
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ".7 * 60 + .3 * 35 + .1 * 0 + 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above could be our prediction for the first row of the data, if our $w$ values are `.7`, `.3`, and `.1`, and our $b$ value is `10`.  We'll discuss how you can calculate the correct $w$ and $b$ values in the next lesson, but for now, let's just use these values.\n",
    "\n",
    "Whenever we want to make a new prediction, we apply the same equation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "58.099999999999994"
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w1 = .7\n",
    "w2 = .3\n",
    "w3 = .1\n",
    "b = 10\n",
    "\n",
    "w1 * 52 + w2 * 39 + w3 * 0 + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix Multiplication\n",
    "\n",
    "What if instead of 3 predictor variables (`tmax`, `tmin`, and `rain`), we had `10`?  Or `100`?  It would get annoying to keep track of that many individual $w$ values.\n",
    "\n",
    "Luckily, we can use linear algebra to help us out.  Matrix multiplication is a linear algebra operation defined like this:\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "    A \\times B =\n",
    "    \\begin{bmatrix}\n",
    "      a_{11} & a_{12} \\\\\n",
    "      a_{21} & a_{22}\n",
    "    \\end{bmatrix}\n",
    "    \\times\n",
    "    \\begin{bmatrix}\n",
    "    b_{11} \\\\\n",
    "    b_{21}\n",
    "    \\end{bmatrix}\n",
    "    =\n",
    "    \\begin{bmatrix}\n",
    "      a_{11}b_{11} + a_{12}b_{21} \\\\\n",
    "      a_{21}b_{11} + a_{22}b_{21}\n",
    "    \\end{bmatrix}\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "We can visualize how it works with this gif:\n",
    "\n",
    "![Matrix mult](images/intro/matrix_mult.gif)\n",
    "\n",
    "As you can see, we essentially take each row of matrix A and multiply it by each column of matrix B, then add everything together.  The number of columns in the first matrix has to equal the number of rows in the second matrix.\n",
    "\n",
    "This is very useful to us when we're multiplying weights by input numbers.  We can take our $x$ values, put them into a matrix, then multiply by the weights (also in a matrix):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "array([[60., 35.,  0.],\n       [52., 39.,  0.],\n       [52., 35.,  0.]])"
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert the first 3 rows of data into a numpy matrix from a pandas dataframe\n",
    "# the first column of the matrix is tmax, second is tmin, third is rain\n",
    "\n",
    "x = data[[\"tmax\", \"tmin\", \"rain\"]].iloc[:3].to_numpy()\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "outputs": [
    {
     "data": {
      "text/plain": "array([0.7, 0.3, 0.1])"
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create a matrix with our weights\n",
    "\n",
    "w = np.array([.7, .3, .1])\n",
    "\n",
    "w"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can verify the shapes of our matrices to make sure they can be multiplied:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "outputs": [
    {
     "data": {
      "text/plain": "(3, 3)"
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the shape (number of rows and columns) in x\n",
    "x.shape"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "outputs": [
    {
     "data": {
      "text/plain": "(3,)"
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Print the shape of w\n",
    "w.shape"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "As we can see, `x` is a matrix with `3` rows and `3` columns.  `w` is actually a vector with `3` columns.  A vector is known as a one-dimensional array, because it only has length in a single dimension.\n",
    "\n",
    "You can also get arrays with more than 2 dimensions, which we'll work with in later lessons.  Each dimension of the array will have a length corresponding to the size in that dimension.\n",
    "\n",
    "`x` has length `3` in dimension `0` (rows) and dimension `1` columns.  `w` has length `3` in dimension `0`.\n",
    "\n",
    "We'll need to convert `w` from a vector into a matrix to multiply our two matrices.  To do that, we can use the numpy `reshape` method.  We pass in our desired lengths in each dimension:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[0.7],\n       [0.3],\n       [0.1]])"
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reshape w into a 3 by 1 matrix\n",
    "# The new dimensions must match the number of elements in w\n",
    "w = w.reshape(3,1)\n",
    "w"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "outputs": [
    {
     "data": {
      "text/plain": "(3, 1)"
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w.shape"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We now have a `3x3` matrix, and a `3x1` matrix.  Since the number of columns in `x` matches the number of rows in `w`, we can multiply them:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[52.5],\n       [48.1],\n       [46.9]])"
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x @ w"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can now add in our $b$ value, `10`.  $b$ is just a single number.  When we add it to `x @ w`, it will be broadcasted across the matrix (added to each element):"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[62.5],\n       [58.1],\n       [56.9]])"
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([10])\n",
    "x @ w + b"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "This gives us the same results as when we manually multiplied our `w` and `x` values:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "outputs": [
    {
     "data": {
      "text/plain": "62.5"
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w1 = .7\n",
    "w2 = .3\n",
    "w3 = .1\n",
    "b = 10\n",
    "\n",
    "w1 * 60 + w2 * 35 + w3 * 0 + b"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "This is the power of matrix multiplication - it enables us to store all of our parameters ($w$ and $b$ values) into arrays and then use them to modify our inputs.  This is a lot faster than keeping track of each individual variable!"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Matrix Transposition\n",
    "\n",
    "Sometimes we'll need to swap dimensions in a matrix.  This is called matrix transposition.  For example, another way to multiply each row in `x` by each weight is to multiply the transposed weights by the transposed x values:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[62.5, 58.1, 56.9]])"
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use .T to get the transpose of a matrix\n",
    "w.T @ x.T + b"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Transposition takes the `3x1` weight matrix, and turns it into a `1x3` matrix.  It then transposes the `3x3` x matrix.  The dimensions of x will stay the same, but transposition will switch the rows and columns:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[0.7, 0.3, 0.1]])"
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w.T"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[60., 52., 52.],\n       [35., 39., 35.],\n       [ 0.,  0.,  0.]])"
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.T"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "`w.T @ x.T` will multiply each column in the weight matrix by each row in the x matrix.  This is the exact same thing that will happen when we do `x @ w`.  It's just that `w.T @ x.T` returns a `1x3` matrix, and `x @ w` returns a `3x1` matrix.  So we need to do another transposition to correct this:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The numpy allclose function tells us if two matrices are approximately equal\n",
    "np.allclose((w.T @ x.T).T, x @ w)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Above, we use `np.allclose` to ensure that both multiplications return the same result.  When comparing the results of matrix multiplication we usually use `np.allclose` instead of `==` because the way computers represent floating point numbers can cause the same number to appear slightly differently.  You can see an explanation for this [here](https://floating-point-gui.de/)."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Broadcasting\n",
    "\n",
    "Earlier, we used broadcasting to add the bias `b` to the result of `x @ w`.  Broadcasting enables arrays with compatible shapes to be added or multiplied.\n",
    "\n",
    "If shapes are compatible, it means that:\n",
    "* The smaller array has all of its dimensions exactly matching the length dimensions of the larger array\n",
    "* Or the smaller array is length 1 in the non-matching dimensions.\n",
    "\n",
    "Here are some examples:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[2.],\n       [2.],\n       [2.],\n       [2.],\n       [2.]])"
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# np.ones enables us to create an array filled with ones of a certain shape\n",
    "\n",
    "A = np.ones((5,1))\n",
    "\n",
    "# This works\n",
    "A + np.ones((1,1))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "outputs": [
    {
     "data": {
      "text/plain": "array([[2.],\n       [2.],\n       [2.],\n       [2.],\n       [2.]])"
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This works\n",
    "A + np.ones((1))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (5,1) (2,1) ",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mValueError\u001B[0m                                Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[39], line 2\u001B[0m\n\u001B[1;32m      1\u001B[0m \u001B[38;5;66;03m# This does not work\u001B[39;00m\n\u001B[0;32m----> 2\u001B[0m \u001B[43mA\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m+\u001B[39;49m\u001B[43m \u001B[49m\u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mones\u001B[49m\u001B[43m(\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m2\u001B[39;49m\u001B[43m,\u001B[49m\u001B[38;5;241;43m1\u001B[39;49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\n",
      "\u001B[0;31mValueError\u001B[0m: operands could not be broadcast together with shapes (5,1) (2,1) "
     ]
    }
   ],
   "source": [
    "# This does not work\n",
    "A + np.ones((2,1))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can also use broadcasting to multiply individual elements:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# np.full initializes an array filled with a given value\n",
    "# Using the * means that each element in array b is multiplied by the elements in array b\n",
    "A * np.full((1,1), 2)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# np.random.rand generates random numbers between 0 and 1 of a given shape\n",
    "A * np.random.rand(5,1)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Scalar Math\n",
    "\n",
    "Arrays can also be modified by scalars (single numbers):"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# np.zeros creates an array filled with zeros\n",
    "# We then add 5 to each value in the array\n",
    "np.zeros((5,1)) + 5"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Array Indexing"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "In NumPy, we can refer to individual elements in arrays using their index.  Indexing starts at 0, just like with Python lists:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Create a 3-dimensional array\n",
    "B = np.random.rand(2,2,2)\n",
    "\n",
    "# Select a single element\n",
    "B[0,1,1]"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Select a slice from dimension 2 (the last dimension)\n",
    "\n",
    "B[0,1,:]"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Select a 2-d slice from the last 2 dimensions\n",
    "B[0]"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Select up to 1 element from the last element\n",
    "B[:,:,:1]"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can also assign to elements using indexing:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "B[0,0,:] = 5\n",
    "B"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Derivatives\n",
    "\n",
    "You'll need to understand derivatives to train neural networks.  Derivatives tell us the rate of change of a function.  For example, the derivative of $x^2$ is $2x$.\n",
    "\n",
    "Let's look at how this works, by first plotting $f(x) = x^2$:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "outputs": [
    {
     "data": {
      "text/plain": "[<matplotlib.lines.Line2D at 0x12319fa00>]"
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Create a list of numbers from -10 to 10, stepping by .1\n",
    "xs = np.arange(-10, 10, .1)\n",
    "# Square all of our x values\n",
    "ys = xs ** 2\n",
    "\n",
    "# Plot the result\n",
    "plt.plot(xs, ys)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "The function graph has a curved shape.  This is because the difference between y values is increasing as x gets further from `0`.   For example, if x is positive, $(x+2) ^ 2 - (x+1) ^ 2$ is greater than $(x+1) ^ 2 - x ^ 2$.  If x is negative, $(x-2) ^ 2 - (x-1) ^ 2$ is greater than $(x-1) ^ 2 - x ^ 2$.  We can also say that the slope of the function is increasing as we get further from `0`.\n",
    "\n",
    "As you can see below, the derivative is the slope between 2 points on the function curve:\n",
    "\n",
    "![slope](images/intro/slope.svg)\n",
    "\n",
    "We can calculate the slope by the equation $\\frac{y_2 - y_1}{x_2 - x_1}$, where $x_2$ and $x_1$ are the x values of 2 points, and $y_2$ and $y_1$ are the y values of the same points."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "outputs": [
    {
     "data": {
      "text/plain": "10.0"
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find 2 x points close to 5\n",
    "x1 = 5 - 1e-8\n",
    "x2 = 5 + 1e-8\n",
    "\n",
    "# Calculate the corresponding y values\n",
    "y1 = x1 ** 2\n",
    "y2 = x2 ** 2\n",
    "\n",
    "# Calculate the slope (or derivative)\n",
    "# This will equal 2 times the midpoint of the x values (5)\n",
    "(y2 - y1) / (x2 - x1)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Derivatives are at a single point, so we would say that $f'(5) = 10$.  This means that the rate of change of $x^2$ at $x=5$ is $10$.\n",
    "\n",
    "We can now plot the derivative, $f'(x) = 2x$:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "outputs": [
    {
     "data": {
      "text/plain": "[<matplotlib.lines.Line2D at 0x12323e7a0>]"
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ys = xs * 2\n",
    "\n",
    "# Plot the derivative\n",
    "plt.plot(xs, ys)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Derivatives are important for training neural networks.  They allow us to determine how much to increase or decrease our parameters.  We'll learn more about this in the next lesson.\n",
    "\n",
    "You usually don't need to know how to find the equation of the derivative yourself, since you'll be given it beforehand.  In a later lesson, we'll discuss how to find the derivative if you need to."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Wrap-up\n",
    "\n",
    "In the next lesson, we'll build on what we learned here to automatically calculate the correct $w$ and $b$ values for linear regression.  This is a key building block of neural networks called gradient descent.  I hope to see you there!"
   ],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}