Pytorch_Zero_to_GANs_Linear_Regression.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Pytorch Zero to GANs-Linear Regression.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyN8tLCgX51xE+8qfN01SvN0",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/philsaurabh/Pytorch-zero-to-GANs-Jovian/blob/main/Pytorch_Zero_to_GANs_Linear_Regression.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EmpUpVpJuGqR"
      },
      "source": [
        "## Introduction to Linear Regression\n",
        "\n",
        "In this tutorial, we'll discuss one of the foundational algorithms in machine learning: *Linear regression*. We'll create a model that predicts crop yields for apples and oranges (*target variables*) by looking at the average temperature, rainfall, and humidity (*input variables or features*) in a region. Here's the training data:\n",
        "\n",
        "![linear-regression-training-data](https://i.imgur.com/6Ujttb4.png)\n",
        "\n",
        "In a linear regression model, each target variable is estimated to be a weighted sum of the input variables, offset by some constant, known as a bias :\n",
        "\n",
        "```\n",
        "yield_apple  = w11 * temp + w12 * rainfall + w13 * humidity + b1\n",
        "yield_orange = w21 * temp + w22 * rainfall + w23 * humidity + b2\n",
        "```\n",
        "\n",
        "Visually, it means that the yield of apples is a linear or planar function of temperature, rainfall and humidity:\n",
        "\n",
        "![linear-regression-graph](https://i.imgur.com/4DJ9f8X.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NMaxIDQ-P1Cv"
      },
      "source": [
        "# Importing Libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j4o_ghOpPXgk"
      },
      "source": [
        "import torch\n",
        "import numpy as np"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZA2SUeIWQVOZ"
      },
      "source": [
        "# Training Data\n",
        "Can be represented usin two metrices :\n",
        "1. inputs\n",
        "2. targets\n",
        "each with one row per observation and one column per variable."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HstCBRDiPgNm"
      },
      "source": [
        "# Input (temp, rainfall, humidity)\n",
        "inputs = np.array([[73, 67, 43], \n",
        "                   [91, 88, 64], \n",
        "                   [87, 134, 58], \n",
        "                   [102, 43, 37], \n",
        "                   [69, 96, 70]], dtype='float32')\n"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eyyLQIEnuPT1",
        "outputId": "c771ed15-f267-4346-b9b5-4c5aff06c4d9"
      },
      "source": [
        "# Targets (apples, oranges)\n",
        "targets = np.array([[56, 70], \n",
        "                    [81, 101], \n",
        "                    [119, 133], \n",
        "                    [22, 37], \n",
        "                    [103, 119]], dtype='float32')\n",
        "print(targets.dtype)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "float32\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "83qgAtsRuZp9"
      },
      "source": [
        "We've separated the input and target variables because we'll operate on them separately. Also, we've created numpy arrays, because this is typically how you would work with training data: read some CSV files as numpy arrays, do some processing, and then convert them to PyTorch tensors."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tBBnUToGue4F"
      },
      "source": [
        "# Tensor conversion"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lojm1RvEuSLw",
        "outputId": "bcd7da36-ae68-46db-ff98-927fb43bd489"
      },
      "source": [
        "# Convert inputs and targets to tensors\n",
        "inputs = torch.from_numpy(inputs)\n",
        "targets = torch.from_numpy(targets)\n",
        "print(inputs)\n",
        "print(targets)\n",
        "print(inputs.dtype)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[ 73.,  67.,  43.],\n",
            "        [ 91.,  88.,  64.],\n",
            "        [ 87., 134.,  58.],\n",
            "        [102.,  43.,  37.],\n",
            "        [ 69.,  96.,  70.]])\n",
            "tensor([[ 56.,  70.],\n",
            "        [ 81., 101.],\n",
            "        [119., 133.],\n",
            "        [ 22.,  37.],\n",
            "        [103., 119.]])\n",
            "torch.float32\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wxJHDG9fvHbv"
      },
      "source": [
        "## Linear regression model from scratch\n",
        "\n",
        "The weights and biases (`w11, w12,... w23, b1 & b2`) can also be represented as matrices, initialized as random values. The first row of `w` and the first element of `b` are used to predict the first target variable, i.e., yield of apples, and similarly, the second for oranges."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C9ycnEOGuoox",
        "outputId": "9b18bfec-697b-4634-c1de-a420042ccd81"
      },
      "source": [
        "# Weights and biases\n",
        "w = torch.randn(2, 3, requires_grad=True)\n",
        "b = torch.randn(2, requires_grad=True)\n",
        "print(w)\n",
        "print(b)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[-1.9791, -2.4543,  1.0714],\n",
            "        [-1.8844, -1.1589,  0.1230]], requires_grad=True)\n",
            "tensor([ 2.6122, -0.6012], requires_grad=True)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nd22LRoqv66q"
      },
      "source": [
        "`torch.randn` creates a tensor with the given shape, with elements picked randomly from a [normal distribution](https://en.wikipedia.org/wiki/Normal_distribution) with mean 0 and standard deviation 1. So, the values enerated will be in the range(-1,1).\n",
        "\n",
        "Our *model* is simply a function that performs a matrix multiplication of the `inputs` and the weights `w` (transposed for the dimension lineup) and adds the bias `b` (replicated for each observation).\n",
        "\n",
        "![matrix-mult](https://i.imgur.com/WGXLFvA.png)\n",
        "\n",
        "We want to predict the target values, but it will predict some different values due to random initial weights.\n",
        "\n",
        "We can define the model as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nOdhrY_fv4cj"
      },
      "source": [
        "def model(x):\n",
        "    return x @ w.t() + b"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RJkOSOmWxQRf"
      },
      "source": [
        "`@` represents matrix multiplication in PyTorch, and the `.t` method returns the transpose of a tensor.\n",
        "\n",
        "The matrix obtained by passing the input data into the model is a set of predictions for the target variables."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vnpNhf5XxM8o",
        "outputId": "95e1d3ee-c97a-45cc-e70c-ca979957f7ed"
      },
      "source": [
        "# Generate predictions\n",
        "preds = model(inputs)\n",
        "print(preds)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[-260.2300, -210.5222],\n",
            "        [-324.8945, -266.1959],\n",
            "        [-436.3055, -312.7047],\n",
            "        [-265.1487, -238.0958],\n",
            "        [-294.5604, -233.2712]], grad_fn=<AddBackward0>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i3csOEBjz6iq"
      },
      "source": [
        "# Comparing with targets"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HgraUxemzvrV",
        "outputId": "80ac9e19-d667-4dc6-bb70-b696457f2093"
      },
      "source": [
        "print(targets)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[ 56.,  70.],\n",
            "        [ 81., 101.],\n",
            "        [119., 133.],\n",
            "        [ 22.,  37.],\n",
            "        [103., 119.]])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FUMUajZ_0EaR"
      },
      "source": [
        "You can see a big difference between our model's predictions and the actual targets because we've initialized our model with random weights and biases. Obviously, we can't expect a randomly initialized model to *just work*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CR1Kkald8WMr"
      },
      "source": [
        "## Loss function\n",
        "\n",
        "Before we improve our model, we need a way to evaluate how well our model is performing. We can compare the model's predictions with the actual targets using the following method:\n",
        "\n",
        "* Calculate the difference between the two matrices (`preds` and `targets`).\n",
        "* Square all elements of the difference matrix to remove negative values.\n",
        "* Calculate the average of the elements in the resulting matrix.\n",
        "\n",
        "The result is a single number, known as the **mean squared error** (MSE)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bESWb0d_0BHU"
      },
      "source": [
        "# MSE loss\n",
        "def mse(t1, t2):\n",
        "    diff = t1 - t2\n",
        "    return torch.sum(diff * diff) / diff.numel()"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HG2meB1w_Ayr"
      },
      "source": [
        "`torch.sum` returns the sum of all the elements in a tensor. The `.numel` method of a tensor returns the number of elements in a tensor. Let's compute the mean squared error for the current predictions of our model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XmhdaRSU-7Cd",
        "outputId": "7bd07f65-8854-463b-b85d-76799380f34b"
      },
      "source": [
        "# Compute loss\n",
        "loss = mse(preds, targets)\n",
        "print(loss)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(142557.5469, grad_fn=<DivBackward0>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d7YT39yA_ZFA"
      },
      "source": [
        "Here’s how we can interpret the result: *On average, each element in the prediction differs from the actual target by the square root of the loss*. And that’s pretty bad, considering the numbers we are trying to predict are themselves in the range 50–200. The result is called the *loss* because it indicates how bad the model is at predicting the target variables. It represents information loss in the model: the lower the loss, the better the model."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N0WpucEF_soc"
      },
      "source": [
        "## Compute gradients\n",
        "\n",
        "With PyTorch, we can automatically compute the gradient or derivative of the loss w.r.t. to the weights and biases because they have `requires_grad` set to `True`. We'll see how this is useful in just a moment."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EUKk_sdh_E37"
      },
      "source": [
        "# Compute gradients\n",
        "loss.backward()"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mPHESnMO_1YW"
      },
      "source": [
        "The gradients are stored in the `.grad` property of the respective tensors. Note that the derivative of the loss w.r.t. the weights matrix is itself a matrix with the same dimensions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WiftXXkm_vxP",
        "outputId": "243d8741-a507-4811-ecf0-5f1c303b25ba"
      },
      "source": [
        "# Gradients for weights\n",
        "print(w)\n",
        "print(w.grad)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[-1.9791, -2.4543,  1.0714],\n",
            "        [-1.8844, -1.1589,  0.1230]], requires_grad=True)\n",
            "tensor([[-33010.7227, -36366.0547, -22047.3203],\n",
            "        [-29007.1484, -31295.9609, -19250.2793]])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2q3uNUbzBetw",
        "outputId": "f6c34782-e02b-4790-bb5d-f9dd54b24db5"
      },
      "source": [
        "print(b)\n",
        "print(b.grad)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([ 2.6122, -0.6012], requires_grad=True)\n",
            "tensor([-392.4279, -344.1580])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e7wa_deICS4s"
      },
      "source": [
        "## Adjust weights and biases to reduce the loss\n",
        "\n",
        "The loss is a [quadratic function](https://en.wikipedia.org/wiki/Quadratic_function) of our weights and biases, and our objective is to find the set of weights where the loss is the lowest. If we plot a graph of the loss w.r.t any individual weight or bias element, it will look like the figure shown below. An important insight from calculus is that the gradient indicates the rate of change of the loss, i.e., the loss function's [slope](https://en.wikipedia.org/wiki/Slope) w.r.t. the weights and biases.\n",
        "\n",
        "If a gradient element is **positive**:\n",
        "\n",
        "* **increasing** the weight element's value slightly will **increase** the loss\n",
        "* **decreasing** the weight element's value slightly will **decrease** the loss\n",
        "\n",
        "![postive-gradient](https://i.imgur.com/WLzJ4xP.png)\n",
        "\n",
        "If a gradient element is **negative**:\n",
        "\n",
        "* **increasing** the weight element's value slightly will **decrease** the loss\n",
        "* **decreasing** the weight element's value slightly will **increase** the loss\n",
        "\n",
        "![negative=gradient](https://i.imgur.com/dvG2fxU.png)\n",
        "\n",
        "The increase or decrease in the loss by changing a weight element is proportional to the gradient of the loss w.r.t. that element. This observation forms the basis of _the gradient descent_ optimization algorithm that we'll use to improve our model (by _descending_ along the _gradient_).\n",
        "\n",
        "We can subtract from each weight element a small quantity proportional to the derivative of the loss w.r.t. that element to reduce the loss slightly."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X6isUsiFJ0EH",
        "outputId": "b8c8bad5-0ffd-46e3-c828-4da6093c8fb0"
      },
      "source": [
        "w\n",
        "w.grad"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[-33010.7227, -36366.0547, -22047.3203],\n",
              "        [-29007.1484, -31295.9609, -19250.2793]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BZqUdS-4JwRi"
      },
      "source": [
        "with torch.no_grad():\n",
        "    w -= w.grad * 1e-5\n",
        "    b -= b.grad * 1e-5"
      ],
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rcmHIo-LJ3fr"
      },
      "source": [
        "We multiply the gradients with a very small number (`10^-5` in this case) to ensure that we don't modify the weights by a very large amount. We want to take a small step in the downhill direction of the gradient, not a giant leap. This number is called the *learning rate* of the algorithm. \n",
        "\n",
        "We use `torch.no_grad` to indicate to PyTorch that we shouldn't track, calculate, or modify gradients while updating the weights and biases."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qhhrNI-zNcdR",
        "outputId": "e31aff43-f33f-4a89-b58c-372d7cb4a0e1"
      },
      "source": [
        "print(w)\n",
        "print(b)"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[-1.6490, -2.0907,  1.2919],\n",
            "        [-1.5944, -0.8459,  0.3155]], requires_grad=True)\n",
            "tensor([ 2.6161, -0.5978], requires_grad=True)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Va_8mvVWKDvY",
        "outputId": "e586eafe-2a68-48ca-e520-0bf8b72c0853"
      },
      "source": [
        "# Let's verify that the loss is actually lower\n",
        "preds=model(inputs)\n",
        "loss = mse(preds, targets)\n",
        "print(loss)"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(96215.3516, grad_fn=<DivBackward0>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A0BJxkYOJ9J1"
      },
      "source": [
        "Before we proceed, we reset the gradients to zero by invoking the `.zero_()` method. We need to do this because PyTorch accumulates gradients. Otherwise, the next time we invoke `.backward` on the loss, the new gradient values are added to the existing gradients, which may lead to unexpected results."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pi66LMBkCPI4",
        "outputId": "d80d7e66-f8ab-4c8b-e226-bc0d7be08e48"
      },
      "source": [
        "w.grad.zero_()\n",
        "b.grad.zero_()\n",
        "print(w.grad)\n",
        "print(b.grad)"
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[0., 0., 0.],\n",
            "        [0., 0., 0.]])\n",
            "tensor([0., 0.])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uIFSH_Q4KO7h"
      },
      "source": [
        "## Train the model using gradient descent\n",
        "\n",
        "As seen above, we reduce the loss and improve our model using the gradient descent optimization algorithm. Thus, we can _train_ the model using the following steps:\n",
        "\n",
        "1. Generate predictions\n",
        "\n",
        "2. Calculate the loss\n",
        "\n",
        "3. Compute gradients w.r.t the weights and biases\n",
        "\n",
        "4. Adjust the weights by subtracting a small quantity proportional to the gradient\n",
        "\n",
        "5. Reset the gradients to zero\n",
        "\n",
        "Let's implement the above step by step."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p3qXCX7rJnMj",
        "outputId": "aedcb581-7762-4b27-d960-87f4944fd038"
      },
      "source": [
        "# Generate predictions\n",
        "preds = model(inputs)\n",
        "print(preds)"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[-202.2827, -160.0976],\n",
            "        [-248.7384, -199.9353],\n",
            "        [-346.0643, -234.3633],\n",
            "        [-207.6790, -187.9252],\n",
            "        [-221.4345, -169.7336]], grad_fn=<AddBackward0>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dXfjHN0wM7hv",
        "outputId": "4fe0172d-6a9f-44bc-c750-6b4c5293d599"
      },
      "source": [
        "# Calculate the loss\n",
        "loss = mse(preds, targets)\n",
        "print(loss)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(96215.3516, grad_fn=<DivBackward0>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2CQ3O6YJM-to",
        "outputId": "27c1607d-9353-4f12-eb30-d309ab7101a7"
      },
      "source": [
        "# Compute gradients\n",
        "loss.backward()\n",
        "print(w.grad)\n",
        "print(b.grad)"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[-27026.9316, -29932.4883, -18078.3359],\n",
            "        [-23801.5664, -25703.1445, -15798.9414]])\n",
            "tensor([-321.4398, -282.4110])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hmSgFierNBbd"
      },
      "source": [
        "# Adjust weights & reset gradients\n",
        "with torch.no_grad():\n",
        "    w -= w.grad * 1e-5\n",
        "    b -= b.grad * 1e-5\n",
        "    w.grad.zero_()\n",
        "    b.grad.zero_()"
      ],
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D7rnDPZzOFDI",
        "outputId": "adda15b4-c48f-4086-fce8-5574f4e11c01"
      },
      "source": [
        "print(w)\n",
        "print(b)"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[-1.3787, -1.7913,  1.4727],\n",
            "        [-1.3564, -0.5889,  0.4735]], requires_grad=True)\n",
            "tensor([ 2.6193, -0.5949], requires_grad=True)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yWJ0OVdXOHgW",
        "outputId": "4e8c7e2f-b4e7-40d4-86d9-7372f8dcedcc"
      },
      "source": [
        "# Calculate loss\n",
        "preds = model(inputs)\n",
        "loss = mse(preds, targets)\n",
        "print(loss)"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(64984.7383, grad_fn=<DivBackward0>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "friURrwqOQ0T"
      },
      "source": [
        "We have already achieved a significant reduction in the loss merely by adjusting the weights and biases slightly using gradient descent."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yV4StAhtOUPt"
      },
      "source": [
        "## Train for multiple epochs\n",
        "\n",
        "To reduce the loss further, we can repeat the process of adjusting the weights and biases using the gradients multiple times. Each iteration is called an _epoch_. Let's train the model for 100 epochs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ka5v_x4zONQ0"
      },
      "source": [
        "lr=1e-5\n",
        "# Train for 100 epochs\n",
        "for i in range(100):\n",
        "    preds = model(inputs)\n",
        "    loss = mse(preds, targets)\n",
        "    loss.backward()\n",
        "    with torch.no_grad():\n",
        "        w -= w.grad * lr\n",
        "        b -= b.grad * lr\n",
        "        w.grad.zero_()\n",
        "        b.grad.zero_()"
      ],
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gyVCBJyoOkTr"
      },
      "source": [
        "Once again, let's verify that the loss is now lower:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ThHQ5jIIOhcr",
        "outputId": "0bcda766-51a7-4cc8-9c41-1196e882f17b"
      },
      "source": [
        "# Calculate loss\n",
        "preds = model(inputs)\n",
        "loss = mse(preds, targets)\n",
        "print(loss)"
      ],
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(104.0998, grad_fn=<DivBackward0>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5tevXAEnOuN6"
      },
      "source": [
        "The loss is now much lower than its initial value. Let's look at the model's predictions and compare them with the targets."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T9w2eOwMOmx-",
        "outputId": "4c353964-bbb5-499e-bb4f-0d5e0b9cb7e8"
      },
      "source": [
        "# Predictions\n",
        "preds"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 57.5515,  70.1764],\n",
              "        [ 92.4889, 102.5352],\n",
              "        [ 94.6958, 128.9282],\n",
              "        [ 21.7820,  37.0082],\n",
              "        [119.9170, 122.2716]], grad_fn=<AddBackward0>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OgPdxBvXOqIG",
        "outputId": "68800881-8802-4371-9f0b-eed81dd010b1"
      },
      "source": [
        "# Targets\n",
        "targets"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 56.,  70.],\n",
              "        [ 81., 101.],\n",
              "        [119., 133.],\n",
              "        [ 22.,  37.],\n",
              "        [103., 119.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b7ULgxlwO4CY"
      },
      "source": [
        "The predictions are now quite close to the target variables. We can get even better results by training for a few more epochs. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CZUgPdGZPUpp"
      },
      "source": [
        "# Linear regression using PyTorch built-ins\n",
        "\n",
        "We've implemented linear regression & gradient descent model using some basic tensor operations. However, since this is a common pattern in deep learning, PyTorch provides several built-in functions and classes to make it easy to create and train models with just a few lines of code.\n",
        "\n",
        "Let's begin by importing the `torch.nn` package from PyTorch, which contains utility classes for building neural networks."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s_ozlVuNO06Z"
      },
      "source": [
        "import torch.nn as nn"
      ],
      "execution_count": 59,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gb_O_O1yPe7A"
      },
      "source": [
        "As before, we represent the inputs and targets and matrices."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_6nJY1ivPf9B"
      },
      "source": [
        "# Input (temp, rainfall, humidity)\n",
        "inputs = np.array([[73, 67, 43], \n",
        "                   [91, 88, 64], \n",
        "                   [87, 134, 58], \n",
        "                   [102, 43, 37], \n",
        "                   [69, 96, 70], \n",
        "                   [74, 66, 43], \n",
        "                   [91, 87, 65], \n",
        "                   [88, 134, 59], \n",
        "                   [101, 44, 37], \n",
        "                   [68, 96, 71], \n",
        "                   [73, 66, 44], \n",
        "                   [92, 87, 64], \n",
        "                   [87, 135, 57], \n",
        "                   [103, 43, 36], \n",
        "                   [68, 97, 70]], \n",
        "                  dtype='float32')\n",
        "\n",
        "# Targets (apples, oranges)\n",
        "targets = np.array([[56, 70], \n",
        "                    [81, 101], \n",
        "                    [119, 133], \n",
        "                    [22, 37], \n",
        "                    [103, 119],\n",
        "                    [57, 69], \n",
        "                    [80, 102], \n",
        "                    [118, 132], \n",
        "                    [21, 38], \n",
        "                    [104, 118], \n",
        "                    [57, 69], \n",
        "                    [82, 100], \n",
        "                    [118, 134], \n",
        "                    [20, 38], \n",
        "                    [102, 120]], \n",
        "                   dtype='float32')\n",
        "\n",
        "inputs = torch.from_numpy(inputs)\n",
        "targets = torch.from_numpy(targets)"
      ],
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MLmw7vkMPuRL",
        "outputId": "96c695d8-de21-462d-96f1-6badf2f20dd1"
      },
      "source": [
        "print(inputs)\n",
        "inputs.dtype"
      ],
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[ 73.,  67.,  43.],\n",
            "        [ 91.,  88.,  64.],\n",
            "        [ 87., 134.,  58.],\n",
            "        [102.,  43.,  37.],\n",
            "        [ 69.,  96.,  70.],\n",
            "        [ 74.,  66.,  43.],\n",
            "        [ 91.,  87.,  65.],\n",
            "        [ 88., 134.,  59.],\n",
            "        [101.,  44.,  37.],\n",
            "        [ 68.,  96.,  71.],\n",
            "        [ 73.,  66.,  44.],\n",
            "        [ 92.,  87.,  64.],\n",
            "        [ 87., 135.,  57.],\n",
            "        [103.,  43.,  36.],\n",
            "        [ 68.,  97.,  70.]])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.float32"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mNk4t0CkQHui"
      },
      "source": [
        "We are using 15 training examples to illustrate how to work with large datasets in small batches. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xz4MMERyQLZB"
      },
      "source": [
        "## Dataset and DataLoader\n",
        "\n",
        "We'll create a `TensorDataset`, which allows access to rows from `inputs` and `targets` as tuples, and provides standard APIs for working with many different types of datasets in PyTorch."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s1zHu2HrQWGQ"
      },
      "source": [
        "from torch.utils.data import TensorDataset"
      ],
      "execution_count": 63,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h0xZ8kBwQI0F",
        "outputId": "475dc907-e650-481d-8731-57867623c865"
      },
      "source": [
        "# Define dataset\n",
        "train_ds = TensorDataset(inputs, targets)\n",
        "train_ds[0:3]"
      ],
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[ 73.,  67.,  43.],\n",
              "         [ 91.,  88.,  64.],\n",
              "         [ 87., 134.,  58.]]), tensor([[ 56.,  70.],\n",
              "         [ 81., 101.],\n",
              "         [119., 133.]]))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gkJdJLHNQZmU",
        "outputId": "e9af31db-223c-4fac-aeb4-9b48389ce254"
      },
      "source": [
        "train_ds[[1,3,7,5]]"
      ],
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[ 91.,  88.,  64.],\n",
              "         [102.,  43.,  37.],\n",
              "         [ 88., 134.,  59.],\n",
              "         [ 74.,  66.,  43.]]), tensor([[ 81., 101.],\n",
              "         [ 22.,  37.],\n",
              "         [118., 132.],\n",
              "         [ 57.,  69.]]))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HtdrxKXlQl-2"
      },
      "source": [
        "The `TensorDataset` allows us to access a small section of the training data using the array indexing notation (`[0:3]` in the above code). It returns a tuple with two elements. The first element contains the input variables for the selected rows, and the second contains the targets.\n",
        "\n",
        "We'll also create a `DataLoader`, which can split the data into batches of a predefined size while training. It also provides other utilities like shuffling and random sampling of the data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uXmzTNB0QzgF"
      },
      "source": [
        "from torch.utils.data import DataLoader"
      ],
      "execution_count": 66,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fMBUboX8ROOy"
      },
      "source": [
        "# Define data loader\n",
        "batch_size = 5\n",
        "train_dl = DataLoader(train_ds, batch_size, shuffle=True)"
      ],
      "execution_count": 67,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DV2ar4DxRRze"
      },
      "source": [
        "We can use the data loader in a `for` loop. Let's look at an example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zTvJTzzARTYG",
        "outputId": "0f32c69b-7f15-4606-8a8d-83c71ec01459"
      },
      "source": [
        "for xb, yb in train_dl:\n",
        "    print(xb)\n",
        "    print(yb)\n",
        "    break"
      ],
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[ 74.,  66.,  43.],\n",
            "        [ 88., 134.,  59.],\n",
            "        [ 91.,  87.,  65.],\n",
            "        [ 91.,  88.,  64.],\n",
            "        [ 69.,  96.,  70.]])\n",
            "tensor([[ 57.,  69.],\n",
            "        [118., 132.],\n",
            "        [ 80., 102.],\n",
            "        [ 81., 101.],\n",
            "        [103., 119.]])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TKhJUK4jRZv5",
        "outputId": "7d6feeee-4eb0-4c45-ddb3-5be07d7ed872"
      },
      "source": [
        "for xb, yb in train_dl:\n",
        "    print('Batch===========')\n",
        "    print(xb)\n",
        "    print(yb)\n",
        "    #break"
      ],
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Batch===========\n",
            "tensor([[ 73.,  66.,  44.],\n",
            "        [101.,  44.,  37.],\n",
            "        [102.,  43.,  37.],\n",
            "        [ 87., 135.,  57.],\n",
            "        [ 73.,  67.,  43.]])\n",
            "tensor([[ 57.,  69.],\n",
            "        [ 21.,  38.],\n",
            "        [ 22.,  37.],\n",
            "        [118., 134.],\n",
            "        [ 56.,  70.]])\n",
            "Batch===========\n",
            "tensor([[ 87., 134.,  58.],\n",
            "        [103.,  43.,  36.],\n",
            "        [ 91.,  88.,  64.],\n",
            "        [ 74.,  66.,  43.],\n",
            "        [ 92.,  87.,  64.]])\n",
            "tensor([[119., 133.],\n",
            "        [ 20.,  38.],\n",
            "        [ 81., 101.],\n",
            "        [ 57.,  69.],\n",
            "        [ 82., 100.]])\n",
            "Batch===========\n",
            "tensor([[ 91.,  87.,  65.],\n",
            "        [ 88., 134.,  59.],\n",
            "        [ 68.,  97.,  70.],\n",
            "        [ 69.,  96.,  70.],\n",
            "        [ 68.,  96.,  71.]])\n",
            "tensor([[ 80., 102.],\n",
            "        [118., 132.],\n",
            "        [102., 120.],\n",
            "        [103., 119.],\n",
            "        [104., 118.]])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v29znT0oRt3r"
      },
      "source": [
        "In each iteration, the data loader returns one batch of data with the given batch size. If `shuffle` is set to `True`, it shuffles the training data before creating batches. Shuffling helps randomize the input to the optimization algorithm, leading to a faster reduction in the loss."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pIxNAGhyRx54"
      },
      "source": [
        "## nn.Linear\n",
        "\n",
        "Instead of initializing the weights & biases manually, we can define the model using the `nn.Linear` class from PyTorch, which does it automatically."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1XfTi-FSRnUc",
        "outputId": "48075476-2d6a-44fb-b92c-04e6c930d277"
      },
      "source": [
        "# Define model\n",
        "model = nn.Linear(3, 2)# 3 inputs and 2 outputs\n",
        "print(model.weight)\n",
        "print(model.bias)"
      ],
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Parameter containing:\n",
            "tensor([[-0.0967,  0.1570,  0.2209],\n",
            "        [ 0.2299,  0.4518,  0.2383]], requires_grad=True)\n",
            "Parameter containing:\n",
            "tensor([ 0.1929, -0.5063], requires_grad=True)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UYzFXs3GSJYo"
      },
      "source": [
        "PyTorch models also have a helpful `.parameters` method, which returns a list containing all the weights and bias matrices present in the model. For our linear regression model, we have one weight matrix and one bias matrix."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wWWXJXavSHC6",
        "outputId": "73f9adcf-6b93-47fe-d32e-3e61b4ae54af"
      },
      "source": [
        "# Parameters\n",
        "list(model.parameters())"
      ],
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([[-0.0967,  0.1570,  0.2209],\n",
              "         [ 0.2299,  0.4518,  0.2383]], requires_grad=True),\n",
              " Parameter containing:\n",
              " tensor([ 0.1929, -0.5063], requires_grad=True)]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZTq6AUXfSfEJ"
      },
      "source": [
        "We can use the model to generate predictions in the same way as before."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IGbQ7T_FSbrp",
        "outputId": "8bd82824-88df-4c7f-e040-c2a1379b3d29"
      },
      "source": [
        "# Generate predictions\n",
        "preds = model(inputs)\n",
        "preds"
      ],
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[13.1522, 56.7912],\n",
              "        [19.3474, 75.4208],\n",
              "        [25.6333, 93.8546],\n",
              "        [ 5.2533, 51.1842],\n",
              "        [24.0566, 75.4079],\n",
              "        [12.8984, 56.5693],\n",
              "        [19.4112, 75.2072],\n",
              "        [25.7574, 94.3227],\n",
              "        [ 5.5070, 51.4062],\n",
              "        [24.3741, 75.4163],\n",
              "        [13.2160, 56.5777],\n",
              "        [19.0936, 75.1988],\n",
              "        [25.5695, 94.0681],\n",
              "        [ 4.9357, 51.1758],\n",
              "        [24.3103, 75.6299]], grad_fn=<AddmmBackward>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nlslV2V9SmS1"
      },
      "source": [
        "## Loss Function\n",
        "\n",
        "Instead of defining a loss function manually, we can use the built-in loss function `mse_loss`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NcuTf4QmSjDJ"
      },
      "source": [
        "# Import nn.functional\n",
        "import torch.nn.functional as F"
      ],
      "execution_count": 73,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AA1dJOciS3zJ"
      },
      "source": [
        "The `nn.functional` package contains many useful loss functions and several other utilities. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "36pUF3OpSy2x"
      },
      "source": [
        "# Define loss function\n",
        "loss_fn = F.mse_loss"
      ],
      "execution_count": 74,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GIA_ZYIAT2IR"
      },
      "source": [
        "# Documentation Function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Fs4eKv0Tu6y"
      },
      "source": [
        "?nn.Linear"
      ],
      "execution_count": 76,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lPBIlqdbT6cN"
      },
      "source": [
        "Let's compute the loss for the current predictions of our model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6BcGtVhTU8kv",
        "outputId": "68ebf09a-2dde-4a05-8d16-c511ee480011"
      },
      "source": [
        "loss = loss_fn(model(inputs), targets)\n",
        "print(loss)"
      ],
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor(2516.8665, grad_fn=<MseLossBackward>)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D9RRbR4_VB4x"
      },
      "source": [
        "## Optimizer\n",
        "\n",
        "Instead of manually manipulating the model's weights & biases using gradients, we can use the optimizer `optim.SGD`. SGD is short for \"stochastic gradient descent\". The term _stochastic_ indicates that samples are selected in random batches instead of as a single group."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GgAZX_qdU-Tg"
      },
      "source": [
        "# Define optimizer\n",
        "opt = torch.optim.SGD(model.parameters(), lr=1e-5)"
      ],
      "execution_count": 79,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YPtT7U5kaZ0_"
      },
      "source": [
        "## Train the model\n",
        "\n",
        "We are now ready to train the model. We'll follow the same process to implement gradient descent:\n",
        "\n",
        "1. Generate predictions\n",
        "\n",
        "2. Calculate the loss\n",
        "\n",
        "3. Compute gradients w.r.t the weights and biases\n",
        "\n",
        "4. Adjust the weights by subtracting a small quantity proportional to the gradient\n",
        "\n",
        "5. Reset the gradients to zero\n",
        "\n",
        "The only change is that we'll work batches of data instead of processing the entire training data in every iteration. Let's define a utility function `fit` that trains the model for a given number of epochs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r4e2IJZMaZd6"
      },
      "source": [
        "# Utility function to train the model\n",
        "def fit(num_epochs, model, loss_fn, opt, train_dl):\n",
        "    \n",
        "    # Repeat for given number of epochs\n",
        "    for epoch in range(num_epochs):\n",
        "        \n",
        "        # Train with batches of data\n",
        "        for xb,yb in train_dl:\n",
        "            \n",
        "            # 1. Generate predictions\n",
        "            pred = model(xb)\n",
        "            \n",
        "            # 2. Calculate loss\n",
        "            loss = loss_fn(pred, yb)\n",
        "            \n",
        "            # 3. Compute gradients\n",
        "            loss.backward()\n",
        "            \n",
        "            # 4. Update parameters using gradients\n",
        "            opt.step()\n",
        "            \n",
        "            # 5. Reset the gradients to zero\n",
        "            opt.zero_grad()\n",
        "        \n",
        "        # Print the progress\n",
        "        if (epoch+1) % 10 == 0:\n",
        "            print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))"
      ],
      "execution_count": 80,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_qRtdYCtb4P0"
      },
      "source": [
        "Some things to note above:\n",
        "\n",
        "* We use the data loader defined earlier to get batches of data for every iteration.\n",
        "\n",
        "* Instead of updating parameters (weights and biases) manually, we use `opt.step` to perform the update and `opt.zero_grad` to reset the gradients to zero.\n",
        "\n",
        "* We've also added a log statement that prints the loss from the last batch of data for every 10th epoch to track training progress. `loss.item` returns the actual value stored in the loss tensor.\n",
        "\n",
        "Let's train the model for 100 epochs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-TxPbxFRaPKX",
        "outputId": "b48ad4a5-fe96-42a1-b415-305b17c58dc8"
      },
      "source": [
        "fit(100, model, loss_fn, opt, train_dl)"
      ],
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch [10/100], Loss: 187.2721\n",
            "Epoch [20/100], Loss: 250.6567\n",
            "Epoch [30/100], Loss: 42.0722\n",
            "Epoch [40/100], Loss: 85.1830\n",
            "Epoch [50/100], Loss: 96.9162\n",
            "Epoch [60/100], Loss: 22.1456\n",
            "Epoch [70/100], Loss: 48.1754\n",
            "Epoch [80/100], Loss: 27.0303\n",
            "Epoch [90/100], Loss: 15.0102\n",
            "Epoch [100/100], Loss: 8.7970\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eqSYBktBb_e1"
      },
      "source": [
        "Let's generate predictions using our model and verify that they're close to our targets."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wypaSe9xcC7R",
        "outputId": "814512bc-3b42-4d11-dd2d-705dba5ba6c4"
      },
      "source": [
        "# Generate predictions\n",
        "preds = model(inputs)\n",
        "preds"
      ],
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 57.9205,  71.3801],\n",
              "        [ 81.3309,  98.2110],\n",
              "        [118.1342, 136.4583],\n",
              "        [ 26.2064,  43.7067],\n",
              "        [ 97.5406, 110.8815],\n",
              "        [ 56.7891,  70.3754],\n",
              "        [ 81.0076,  97.8197],\n",
              "        [118.3650, 136.8333],\n",
              "        [ 27.3378,  44.7114],\n",
              "        [ 98.3488, 111.4949],\n",
              "        [ 57.5973,  70.9887],\n",
              "        [ 80.1995,  97.2063],\n",
              "        [118.4574, 136.8496],\n",
              "        [ 25.3982,  43.0934],\n",
              "        [ 98.6720, 111.8862]], grad_fn=<AddmmBackward>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3qCDJqEHcFmm",
        "outputId": "a0e356f8-f19f-48f9-de01-902275e0164f"
      },
      "source": [
        "# Compare with targets\n",
        "targets"
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 56.,  70.],\n",
              "        [ 81., 101.],\n",
              "        [119., 133.],\n",
              "        [ 22.,  37.],\n",
              "        [103., 119.],\n",
              "        [ 57.,  69.],\n",
              "        [ 80., 102.],\n",
              "        [118., 132.],\n",
              "        [ 21.,  38.],\n",
              "        [104., 118.],\n",
              "        [ 57.,  69.],\n",
              "        [ 82., 100.],\n",
              "        [118., 134.],\n",
              "        [ 20.,  38.],\n",
              "        [102., 120.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xzdvw5AscJDP"
      },
      "source": [
        "Indeed, the predictions are quite close to our targets. We have a trained a reasonably good model to predict crop yields for apples and oranges by looking at the average temperature, rainfall, and humidity in a region. We can use it to make predictions of crop yields for new regions by passing a batch containing a single row of input."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C89bnQYpcIjv",
        "outputId": "f9f3ce08-35e7-4683-ba49-21b8464cebf2"
      },
      "source": [
        "model(torch.tensor([[75, 63, 44.]]))"
      ],
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[54.4917, 68.0938]], grad_fn=<AddmmBackward>)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NXKN14EXcSy3"
      },
      "source": [
        "## Machine Learning vs. Classical Programming\n",
        "\n",
        "The approach we've taken in this tutorial is very different from programming as you might know it. Usually, we write programs that take some inputs, perform some operations, and return a result. \n",
        "\n",
        "However, in this notebook, we've defined a \"model\" that assumes a specific relationship between the inputs and the outputs, expressed using some unknown parameters (weights & biases). We then show the model some know inputs and outputs and _train_ the model to come up with good values for the unknown parameters. Once trained, the model can be used to compute the outputs for new inputs.\n",
        "\n",
        "This paradigm of programming is known as _machine learning_, where we use data to figure out the relationship between inputs and outputs. _Deep learning_ is a branch of machine learning that uses matrix operations, non-linear activation functions and gradient descent to build and train models. Andrej Karpathy, the director of AI at Tesla Motors, has written a great blog post on this topics, titled [Software 2.0](https://medium.com/@karpathy/software-2-0-a64152b37c35).\n",
        "\n",
        "This picture from book [Deep Learning with Python](https://www.manning.com/books/deep-learning-with-python) by Francois Chollet captures the difference between classical programming and machine learning:\n",
        "\n",
        "![](https://i.imgur.com/oJEQe7k.png)\n",
        "\n",
        "Keep this picture in mind as you work through the next few tutorials. \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XBujUVJAPHvV"
      },
      "source": [
        "## Exercises and Further Reading\n",
        "\n",
        "We've covered the following topics in this tutorial:\n",
        "\n",
        "- Introduction to linear regression and gradient descent\n",
        "- Implementing a linear regression model using PyTorch tensors\n",
        "- Training a linear regression model using the gradient descent algorithm\n",
        "- Implementing gradient descent and linear regression using PyTorch built-in\n",
        "\n",
        "\n",
        "Here are some resources for learning more about linear regression and gradient descent:\n",
        "\n",
        "* An visual & animated explanation of gradient descent: https://www.youtube.com/watch?v=IHZwWFHWa-w\n",
        "\n",
        "* For a more detailed explanation of derivates and gradient descent, see [these notes from a Udacity course](https://storage.googleapis.com/supplemental_media/udacityu/315142919/Gradient%20Descent.pdf). \n",
        "\n",
        "* For an animated visualization of how linear regression works, [see this post](https://hackernoon.com/visualizing-linear-regression-with-pytorch-9261f49edb09).\n",
        "\n",
        "* For a more mathematical treatment of matrix calculus, linear regression and gradient descent, you should check out [Andrew Ng's excellent course notes](https://github.com/Cleo-Stanford-CS/CS229_Notes/blob/master/lectures/cs229-notes1.pdf) from CS229 at Stanford University.\n",
        "\n",
        "* To practice and test your skills, you can participate in the [Boston Housing Price Prediction](https://www.kaggle.com/c/boston-housing) competition on Kaggle, a website that hosts data science competitions.\n",
        "\n",
        "With this, we complete our discussion of linear regression in PyTorch, and we’re ready to move on to the next topic: [Working with Images & Logistic Regression](https://jovian.ai/aakashns/03-logistic-regression)."
      ]
    }
  ]
}