linear_regression_pytorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "x = np.array([[1,2],[3,4.]])\n",
        "x\n",
        "y = torch.tensor(x)\n",
        "y\n",
        "print(x.dtype, y.dtype)\n",
        "\n",
        "t3 = torch.tensor([\n",
        "    [[11,12,13,14],\n",
        "     [13,14,15,16]],\n",
        "    [[15,16,17,18],\n",
        "     [16,17,18,19.]],\n",
        "    [[15,16,17,18],\n",
        "     [16,17,18,19.]]\n",
        "])\n",
        "t3\n",
        "t3.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-C7myvk8ZJwX",
        "outputId": "8e8615c0-380d-4c1d-9f3e-49e706f53514"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "float64 torch.float64\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([3, 2, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = torch.tensor(3.)\n",
        "w = torch.tensor(4., requires_grad=True)\n",
        "b = torch.tensor(5., requires_grad=True)\n",
        "y = w * x + b\n",
        "y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZKgryh_wZd1d",
        "outputId": "f0b2280b-ba1f-4f05-a810-819002e1227f"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(17., grad_fn=<AddBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y.backward()\n",
        "print('dy/dx', x.grad)\n",
        "print('dy/dw', w.grad)\n",
        "print('dy/db', b.grad)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H11BbpHobiNy",
        "outputId": "6c2d53bf-6bab-4f9e-8f2f-d9ef07c09b87"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "dy/dx None\n",
            "dy/dw tensor(3.)\n",
            "dy/db tensor(1.)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "RS8lVhPb7V7e"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import math\n",
        "#region, temp,rain,humidity,apples,oranges\n",
        "#kanto, 73, 67, 43, 56, 70\n",
        "#johto, 91, 88, 64 ,81, 101\n",
        "#hoen, 87, 134, 58, 119, 133\n",
        "#sinnoh, 102, 43,37, 22, 37\n",
        "#unova, 69, 96, 70, 103, 119\n",
        "#yield_apple = w11 * temp + w12 * rainfall + w13 * humidity + b1\n",
        "#yield_orange = w21 * temp + w22 * rainfall + w23 * humidity + b2\n",
        "\n",
        "inputs = np.array([\n",
        "[73,67,43],\n",
        "[91,88,64],\n",
        "[87,134,58],\n",
        "[102,43,37],\n",
        "[69,96,70]], dtype='float32')\n",
        "targets = np.array([\n",
        "[56,70],\n",
        "[81,101],\n",
        "[119,133],\n",
        "[22,37],\n",
        "[103,119]], dtype='float32')\n",
        "#avg 76.2, 92\n",
        "inputs = torch.tensor(inputs)\n",
        "targets = torch.from_numpy(targets)\n",
        "print(inputs.shape)\n",
        "print(targets.shape)\n",
        "print(inputs)\n",
        "print(targets)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_S_97owUcAJP",
        "outputId": "a07ecabd-1934-4070-d705-9fb8b0bff0fd"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([5, 3])\n",
            "torch.Size([5, 2])\n",
            "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "torch.randn creates a tensor with the given shape, with elements pickedrandomly from a normal distribution with mean 0 and stand deviation 1.\n",
        "Model is a function that performs a matrix multiplication of the inputs and the weights w (transposed) and adds the bias b (replicated for each observation)"
      ],
      "metadata": {
        "id": "Jw8Mx2X27lfZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "w = torch.randn(2,3,requires_grad=True)\n",
        "b = torch.randn(2,requires_grad=True)\n",
        "print(w)\n",
        "print(b)\n",
        "def model(x):\n",
        "    return x @ w.t() + b"
      ],
      "metadata": {
        "id": "C5nHs1aX8Rjg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "84300cf1-122b-4267-bb9e-0ca83e94981e"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[-0.9184, -2.1439, -0.0340],\n",
            "        [ 0.0606, -0.0868,  0.0777]], requires_grad=True)\n",
            "tensor([-0.3817, -0.4314], requires_grad=True)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "@ represents matrix mulitiplication, and .t metod returns transpose of a tensor.\n",
        "matrix obtained by passing the input data into the model is a set of predictions for the target vars."
      ],
      "metadata": {
        "id": "SUw5_ZoM9DRI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "preds = model(inputs)\n",
        "print(preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VacWLX7f9Eim",
        "outputId": "06b6a1eb-20d3-43ac-9a85-8890c0423ba8"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[-212.5319,    1.5186],\n",
            "        [-274.8000,    2.4184],\n",
            "        [-369.5440,   -2.2839],\n",
            "        [-187.5075,    4.8939],\n",
            "        [-271.9502,    0.8565]], grad_fn=<AddBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "diff = preds - targets\n",
        "print(diff)\n",
        "diff_sqr = diff * diff\n",
        "print(diff_sqr)\n",
        "manual_mse = torch.sum(diff_sqr) / diff.numel()\n",
        "print(manual_mse)\n",
        "print(math.sqrt(manual_mse))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YNBX90GsFR1J",
        "outputId": "26d5a186-6c4f-454f-e5b1-614469ab9c40"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[-268.5319,  -68.4814],\n",
            "        [-355.8000,  -98.5816],\n",
            "        [-488.5440, -135.2840],\n",
            "        [-209.5075,  -32.1061],\n",
            "        [-374.9502, -118.1435]], grad_fn=<SubBackward0>)\n",
            "tensor([[ 72109.3906,   4689.7085],\n",
            "        [126593.6328,   9718.3281],\n",
            "        [238675.2188,  18301.7480],\n",
            "        [ 43893.3750,   1030.7993],\n",
            "        [140587.6719,  13957.8945]], grad_fn=<MulBackward0>)\n",
            "tensor(66955.7812, grad_fn=<DivBackward0>)\n",
            "258.75815204549593\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def mse(t1,t2):\n",
        "  diff = t1 - t2\n",
        "  return torch.sum(diff * diff) / diff.numel()\n",
        "loss = mse(preds, targets)\n",
        "print(loss)"
      ],
      "metadata": {
        "id": "38MLkb1I_mkf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c91b79bb-5dc8-4bcf-f289-dd91b4c21431"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(66955.7812, grad_fn=<DivBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ".nume1 method returns the nummber of elements in a tensor\n",
        "Loss is quadratic function of weights and bieases"
      ],
      "metadata": {
        "id": "0Cu1wswXFpHZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "After calling backward(), the gradients are stored in the .grad attribute of the tensors."
      ],
      "metadata": {
        "id": "J1gew-KFVJZ9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "gradients are stored in the .grad property of the respective tensors. Note derivative of the loss w.r.t. the weights matrix is itself a matrix, with same dimentsion"
      ],
      "metadata": {
        "id": "PTJ2vNgLHYsG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "preds = model(inputs)\n",
        "loss = mse(preds, targets)\n",
        "loss.backward()\n",
        "print(w)\n",
        "print(b)\n",
        "print(w.grad)\n",
        "print(b.grad)\n",
        "print(loss)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZcHqFZTmJbFW",
        "outputId": "2ead5915-8050-49ad-fca8-3f94ed549f8c"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[-0.9184, -2.1439, -0.0340],\n",
            "        [ 0.0606, -0.0868,  0.0777]], requires_grad=True)\n",
            "tensor([-0.3817, -0.4314], requires_grad=True)\n",
            "tensor([[-28345.0547, -31954.1953, -19330.3828],\n",
            "        [ -7433.2993,  -8822.7656,  -5311.6729]])\n",
            "tensor([-339.4667,  -90.5193])\n",
            "tensor(66955.7812, grad_fn=<DivBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with torch.no_grad():\n",
        "  w -= w.grad * 1e-5\n",
        "  b -= b.grad * 1e-5\n",
        "  w.grad.zero_()\n",
        "  b.grad.zero_()\n",
        "print(w)\n",
        "print(b)"
      ],
      "metadata": {
        "id": "bjZrgBSDTZc6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "52451915-5c19-4d74-ca48-9f42c39a3c7c"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[-6.3497e-01, -1.8244e+00,  1.5932e-01],\n",
            "        [ 1.3495e-01,  1.4096e-03,  1.3082e-01]], requires_grad=True)\n",
            "tensor([-0.3783, -0.4305], requires_grad=True)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "preds = model(inputs)\n",
        "loss = mse(preds, targets)\n",
        "print(loss)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f8UJ5dIedG0x",
        "outputId": "92fd9e46-8f2c-42c0-83ff-7af6fc7f6aae"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(45471.4609, grad_fn=<DivBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Significant Reduction of Loss!!!"
      ],
      "metadata": {
        "id": "P-p-uY06dQ2A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(1000):\n",
        "  preds = model(inputs)\n",
        "  loss = mse(preds, targets)\n",
        "  loss.backward()\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_()"
      ],
      "metadata": {
        "id": "rLii0i6EdU3f"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "preds = model(inputs)\n",
        "loss = mse(preds, targets)\n",
        "print(loss)\n",
        "print(math.sqrt(loss))\n",
        "print(b)\n",
        "print(w)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G1LayMo7eRPZ",
        "outputId": "92dd5253-3aac-46f9-98b1-5257c64fe6cc"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(4.4609, grad_fn=<DivBackward0>)\n",
            "2.112086270239298\n",
            "tensor([-0.3727, -0.4299], requires_grad=True)\n",
            "tensor([[-0.4402,  0.7721,  0.8775],\n",
            "        [-0.2532,  0.8666,  0.7272]], requires_grad=True)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "========================================================"
      ],
      "metadata": {
        "id": "jnfIVwTNphtY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "from torch.utils.data import TensorDataset\n",
        "from torch.utils.data import DataLoader\n",
        "import torch.nn.functional as F\n",
        "inputs = np.array([\n",
        "[73,67,43],\n",
        "[91,88,64],\n",
        "[87,134,58],\n",
        "[73,67,43],\n",
        "[91,88,64],\n",
        "[87,134,58],\n",
        "[102,43,37],\n",
        "[69,96,70],\n",
        "[102,43,37],\n",
        "[69,96,70],\n",
        "[73,67,43],\n",
        "[91,88,64],\n",
        "[87,134,58],\n",
        "[102,43,37],\n",
        "[69,96,70]], dtype='float32')\n",
        "\n",
        "targets = np.array([\n",
        "[56,70],\n",
        "[81,101],\n",
        "[119,133],\n",
        "[56,70],\n",
        "[81,101],\n",
        "[119,133],\n",
        "[22,37],\n",
        "[103,119],\n",
        "[22,37],\n",
        "[103,119],\n",
        "[56,70],\n",
        "[81,101],\n",
        "[119,133],\n",
        "[22,37],\n",
        "[103,119]], dtype='float32')\n",
        "#avg 76.2, 92\n",
        "inputs = torch.tensor(inputs)\n",
        "targets = torch.from_numpy(targets)\n",
        "print(inputs.shape)\n",
        "print(targets.shape)\n",
        "print(inputs)\n",
        "print(targets)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ITh2Kg2tpkMT",
        "outputId": "d968ebbc-8372-46fd-ed0a-8b233a654a6e"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([15, 3])\n",
            "torch.Size([15, 2])\n",
            "tensor([[ 73.,  67.,  43.],\n",
            "        [ 91.,  88.,  64.],\n",
            "        [ 87., 134.,  58.],\n",
            "        [ 73.,  67.,  43.],\n",
            "        [ 91.,  88.,  64.],\n",
            "        [ 87., 134.,  58.],\n",
            "        [102.,  43.,  37.],\n",
            "        [ 69.,  96.,  70.],\n",
            "        [102.,  43.,  37.],\n",
            "        [ 69.,  96.,  70.],\n",
            "        [ 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",
            "        [ 56.,  70.],\n",
            "        [ 81., 101.],\n",
            "        [119., 133.],\n",
            "        [ 22.,  37.],\n",
            "        [103., 119.],\n",
            "        [ 22.,  37.],\n",
            "        [103., 119.],\n",
            "        [ 56.,  70.],\n",
            "        [ 81., 101.],\n",
            "        [119., 133.],\n",
            "        [ 22.,  37.],\n",
            "        [103., 119.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#define dataset\n",
        "train_ds = TensorDataset(inputs, targets)\n",
        "train_ds[0:3]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5j9dZooZrpj3",
        "outputId": "fc387c2e-f6c1-405d-dae5-b9b0c75b3d38"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[ 73.,  67.,  43.],\n",
              "         [ 91.,  88.,  64.],\n",
              "         [ 87., 134.,  58.]]),\n",
              " tensor([[ 56.,  70.],\n",
              "         [ 81., 101.],\n",
              "         [119., 133.]]))"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "TDset allows access to small section of training data using array [0:3]. returning a typle pair in which 1st element contains input variables for selected rows and 2nd, the target"
      ],
      "metadata": {
        "id": "Jd9N6vm9rxun"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size = 5\n",
        "#manual\n",
        "train_dl = DataLoader(train_ds, batch_size, shuffle=True)\n",
        "for xb, yb in train_dl:\n",
        "  print(xb)\n",
        "  print(yb)\n",
        "  break"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E8B-k1-xsHX-",
        "outputId": "882f2b23-c04a-49e4-9a0c-595eece058ab"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[ 69.,  96.,  70.],\n",
            "        [102.,  43.,  37.],\n",
            "        [ 73.,  67.,  43.],\n",
            "        [ 69.,  96.,  70.],\n",
            "        [ 91.,  88.,  64.]])\n",
            "tensor([[103., 119.],\n",
            "        [ 22.,  37.],\n",
            "        [ 56.,  70.],\n",
            "        [103., 119.],\n",
            "        [ 81., 101.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model = nn.Linear(3,2)\n",
        "print(model.weight)\n",
        "print(model.bias)\n",
        "\n",
        "preds = model(inputs)\n",
        "print(preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vrL0YZyovOY5",
        "outputId": "c7b6c902-0156-41cf-8c81-4891e2d9efa9"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Parameter containing:\n",
            "tensor([[-0.3273,  0.5289, -0.0542],\n",
            "        [-0.1197,  0.4837, -0.0051]], requires_grad=True)\n",
            "Parameter containing:\n",
            "tensor([0.0767, 0.2993], requires_grad=True)\n",
            "tensor([[  9.2905,  23.7442],\n",
            "        [ 13.3684,  31.6388],\n",
            "        [ 39.3337,  54.3965],\n",
            "        [  9.2905,  23.7442],\n",
            "        [ 13.3684,  31.6388],\n",
            "        [ 39.3337,  54.3965],\n",
            "        [-12.5714,   8.6943],\n",
            "        [ 24.4760,  38.1119],\n",
            "        [-12.5714,   8.6943],\n",
            "        [ 24.4760,  38.1119],\n",
            "        [  9.2905,  23.7442],\n",
            "        [ 13.3684,  31.6388],\n",
            "        [ 39.3337,  54.3965],\n",
            "        [-12.5714,   8.6943],\n",
            "        [ 24.4760,  38.1119]], grad_fn=<AddmmBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loss_fn = F.mse_loss\n",
        "loss = loss_fn(model(inputs), targets)\n",
        "print(loss)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GYD42mqiwOzk",
        "outputId": "d470260c-6063-47a1-fba1-5666df4ad3cc"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(4093.6907, grad_fn=<MseLossBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "opt = torch.optim.SGD(model.parameters(), lr=1e-5)"
      ],
      "metadata": {
        "id": "XigUU0APx037"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Generate predictions\n",
        "2. Calculate the loss\n",
        "3. Compute gradients with respect to Weights and Biases\n",
        "4. Adjust the weights by subtracting a small quantity proportional to the gradient\n",
        "5. Reset gradients to zero"
      ],
      "metadata": {
        "id": "lx5tiyJLzE3_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def fit(num_epochs, model, loss_fn, opt):\n",
        "  for epoch in range(num_epochs):\n",
        "    for xb, yb in train_dl:\n",
        "      pred = model(xb)\n",
        "      loss = loss_fn(pred, yb)\n",
        "      loss.backward()\n",
        "      opt.step()\n",
        "      opt.zero_grad()\n",
        "    if (epoch+1) % 10 == 0:\n",
        "      print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))"
      ],
      "metadata": {
        "id": "T5F6S0G3yvG6"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Stochastic Gradient Descent (stochastic due to batches instead of single group)"
      ],
      "metadata": {
        "id": "UWbVHyTSx43C"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        ".parameters method returns list containing all weights and bias matrices"
      ],
      "metadata": {
        "id": "Vl9IhhN8vrKr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fit(100, model, loss_fn, opt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GRw6uxR4z7eA",
        "outputId": "d15251b2-d700-4475-a8fd-e4396d754a52"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [10/100], Loss: 62.1032\n",
            "Epoch [20/100], Loss: 92.1569\n",
            "Epoch [30/100], Loss: 8.8954\n",
            "Epoch [40/100], Loss: 29.2640\n",
            "Epoch [50/100], Loss: 48.4565\n",
            "Epoch [60/100], Loss: 43.5415\n",
            "Epoch [70/100], Loss: 17.9307\n",
            "Epoch [80/100], Loss: 47.0508\n",
            "Epoch [90/100], Loss: 41.2304\n",
            "Epoch [100/100], Loss: 42.1171\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "preds = model(inputs)\n",
        "preds\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JP9k43sV0KXd",
        "outputId": "f84d3e0c-bdcf-410f-e186-bd531b776cde"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 58.0348,  71.4776],\n",
              "        [ 79.7019,  97.3358],\n",
              "        [123.8129, 139.7469],\n",
              "        [ 58.0348,  71.4776],\n",
              "        [ 79.7019,  97.3358],\n",
              "        [123.8129, 139.7469],\n",
              "        [ 25.0967,  42.2390],\n",
              "        [ 95.1756, 110.2697],\n",
              "        [ 25.0967,  42.2390],\n",
              "        [ 95.1756, 110.2697],\n",
              "        [ 58.0348,  71.4776],\n",
              "        [ 79.7019,  97.3358],\n",
              "        [123.8129, 139.7469],\n",
              "        [ 25.0967,  42.2390],\n",
              "        [ 95.1756, 110.2697]], grad_fn=<AddmmBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "targets"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cUHO5RWg0SpT",
        "outputId": "c4203352-d2ab-46ef-811b-b893ce3a2a8c"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[ 56.,  70.],\n",
              "        [ 81., 101.],\n",
              "        [119., 133.],\n",
              "        [ 56.,  70.],\n",
              "        [ 81., 101.],\n",
              "        [119., 133.],\n",
              "        [ 22.,  37.],\n",
              "        [103., 119.],\n",
              "        [ 22.,  37.],\n",
              "        [103., 119.],\n",
              "        [ 56.,  70.],\n",
              "        [ 81., 101.],\n",
              "        [119., 133.],\n",
              "        [ 22.,  37.],\n",
              "        [103., 119.]])"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    }
  ]
}