torch_linear_reg_II_03.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/anishchapagain/Deep-Learning/blob/main/torch_linear_reg_II_03.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7bHhKrWuaoCJ"
      },
      "source": [
        "## PyTorch for Deep Learning Models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YW-dThHVkvTK"
      },
      "source": [
        "Linear Regression Model Training in PyTorch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fXZlkC3HaWiQ"
      },
      "outputs": [],
      "source": [
        "import torch"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lpIDox44fEJ5"
      },
      "source": [
        "Input Data: tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y-Cu1s53fH8C",
        "outputId": "7b9cc550-2dc9-454e-8ad0-c69a309ad311"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor([[1.],\n",
            "        [2.],\n",
            "        [3.],\n",
            "        [4.]])\n"
          ]
        }
      ],
      "source": [
        "X = torch.tensor([[1.0], [2.0], [3.0], [4.0]])\n",
        "print(X)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_MfJxubofTtx"
      },
      "source": [
        "Expected Output: y = 5x+1<br><b>Learning_weight:5, Learning_bias:1</b><br>\n",
        "example: x=1, y=5*1+1 = 6"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oxVPcxu2faWy",
        "outputId": "8e817b73-a517-4242-9c94-c2604e749153"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor([[ 6.],\n",
            "        [11.],\n",
            "        [15.],\n",
            "        [21.]])\n"
          ]
        }
      ],
      "source": [
        "y = torch.tensor([[6.0], [11.0], [15.0], [21.0]]) # 21 = 5*4+1\n",
        "print(y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X8J9P6w2Nova",
        "outputId": "78263271-1f34-4cff-8cdc-817253a8dbc5"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(4, 4)"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(X), len(y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jjFWGXyqfnsS"
      },
      "source": [
        "Input data, Model Parameter (weight & bias), Output Data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hN56xaRygAZz"
      },
      "source": [
        "Define the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aRjXAbZYgFnR",
        "outputId": "d0b1ae3c-cb8b-4914-8a10-e0293e7d4f75"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Linear(in_features=1, out_features=1, bias=True)\n"
          ]
        }
      ],
      "source": [
        "# model = torch.nn.Linear(1, 1)  # Input size: 1, Output size: 1 , model= torch.nn.Linear(20, 30)\n",
        "\n",
        "model = torch.nn.Linear(1, 1)\n",
        "print(model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hmsmt7uIOCMh",
        "outputId": "100db5b4-5b2d-4498-eabf-b7474374be6f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "OrderedDict([('weight', tensor([[-0.0690]])), ('bias', tensor([-0.8796]))])"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.state_dict()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XJeJeAeVOI8K",
        "outputId": "8602df9a-967b-4008-8f34-4df48fe2c7d9"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([[-0.0690]], requires_grad=True),\n",
              " Parameter containing:\n",
              " tensor([-0.8796], requires_grad=True)]"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "list(model.parameters())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BaGuNnn3qq81",
        "outputId": "3b9a6ef2-5c53-4427-9568-db729f368ed3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Weight: Parameter containing:\n",
            "tensor([[-0.0690]], requires_grad=True)\n",
            "Bias: Parameter containing:\n",
            "tensor([-0.8796], requires_grad=True)\n"
          ]
        }
      ],
      "source": [
        "print(f\"Weight: {model.weight}\")\n",
        "print(f\"Bias: {model.bias}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P_oMk3_EjsBw"
      },
      "source": [
        "The weights and biases of the layer are initialized randomly and learned during the training process"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KfPe40BKqPat",
        "outputId": "726b902a-e90f-495b-ed48-839b72ece60d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Linear(in_features=2, out_features=5, bias=True)\n",
            "Parameter containing:\n",
            "tensor([[-0.4470, -0.6388],\n",
            "        [ 0.4378,  0.0953],\n",
            "        [ 0.3476, -0.4315],\n",
            "        [ 0.5936,  0.4835],\n",
            "        [ 0.2164, -0.5710]], requires_grad=True)\n",
            "Parameter containing:\n",
            "tensor([ 0.5124, -0.4977, -0.0937,  0.1736,  0.1184], requires_grad=True)\n"
          ]
        }
      ],
      "source": [
        "models = torch.nn.Linear(2, 5)\n",
        "print(models)\n",
        "print(models.weight)\n",
        "print(models.bias)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DjSlclG2gKSR"
      },
      "source": [
        "Train the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "X21MwWhzgQgQ"
      },
      "outputs": [],
      "source": [
        "# The optimizer updates the model parameters based on the computed gradients\n",
        "learning_rate = 0.01\n",
        "loss_fn = torch.nn.L1Loss()\n",
        "\n",
        "# The model is trained using stochastic gradient descent (SGD) optimization\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) # Adam"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5s58vmbHKsT5",
        "outputId": "342c4e82-40a5-4485-87ac-41ac7d4181f6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "OrderedDict([('weight', tensor([[-0.0690]])), ('bias', tensor([-0.8796]))])"
            ]
          },
          "execution_count": 18,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.state_dict()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ia-mqxnPL83a",
        "outputId": "8f8f1420-076a-4b8c-cd19-12d4e4f6340a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<generator object Module.parameters at 0x790424ad0580>"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.parameters()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8bf9ytEYgSiy",
        "outputId": "9ebcdd49-b5cb-49e5-b7f3-9f8547f73ab1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Loss: 0.1776466816663742\n",
            "OrderedDict([('weight', tensor([[4.9427]])), ('bias', tensor([0.8745]))])\n",
            "Epoch 0, Loss: 0.1776466816663742\n",
            "Loss: 0.17763108015060425\n",
            "OrderedDict([('weight', tensor([[4.9426]])), ('bias', tensor([0.8749]))])\n",
            "Loss: 0.17761534452438354\n",
            "OrderedDict([('weight', tensor([[4.9424]])), ('bias', tensor([0.8752]))])\n",
            "Loss: 0.1775994896888733\n",
            "OrderedDict([('weight', tensor([[4.9423]])), ('bias', tensor([0.8756]))])\n",
            "Loss: 0.1775839924812317\n",
            "OrderedDict([('weight', tensor([[4.9422]])), ('bias', tensor([0.8760]))])\n",
            "Loss: 0.1775687336921692\n",
            "OrderedDict([('weight', tensor([[4.9421]])), ('bias', tensor([0.8764]))])\n",
            "Loss: 0.17755332589149475\n",
            "OrderedDict([('weight', tensor([[4.9419]])), ('bias', tensor([0.8767]))])\n",
            "Loss: 0.17753808200359344\n",
            "OrderedDict([('weight', tensor([[4.9418]])), ('bias', tensor([0.8771]))])\n",
            "Loss: 0.17752256989479065\n",
            "OrderedDict([('weight', tensor([[4.9417]])), ('bias', tensor([0.8775]))])\n",
            "Loss: 0.1775076538324356\n",
            "OrderedDict([('weight', tensor([[4.9416]])), ('bias', tensor([0.8778]))])\n",
            "Loss: 0.17749297618865967\n",
            "OrderedDict([('weight', tensor([[4.9414]])), ('bias', tensor([0.8782]))])\n",
            "Loss: 0.17747759819030762\n",
            "OrderedDict([('weight', tensor([[4.9413]])), ('bias', tensor([0.8786]))])\n",
            "Loss: 0.17746272683143616\n",
            "OrderedDict([('weight', tensor([[4.9412]])), ('bias', tensor([0.8789]))])\n",
            "Loss: 0.1774485856294632\n",
            "OrderedDict([('weight', tensor([[4.9411]])), ('bias', tensor([0.8793]))])\n",
            "Loss: 0.177433580160141\n",
            "OrderedDict([('weight', tensor([[4.9409]])), ('bias', tensor([0.8796]))])\n",
            "Loss: 0.17741923034191132\n",
            "OrderedDict([('weight', tensor([[4.9408]])), ('bias', tensor([0.8800]))])\n",
            "Loss: 0.17740459740161896\n",
            "OrderedDict([('weight', tensor([[4.9407]])), ('bias', tensor([0.8804]))])\n",
            "Loss: 0.1773902028799057\n",
            "OrderedDict([('weight', tensor([[4.9406]])), ('bias', tensor([0.8807]))])\n",
            "Loss: 0.17737606167793274\n",
            "OrderedDict([('weight', tensor([[4.9404]])), ('bias', tensor([0.8811]))])\n",
            "Loss: 0.17736169695854187\n",
            "OrderedDict([('weight', tensor([[4.9403]])), ('bias', tensor([0.8814]))])\n",
            "Loss: 0.1773476004600525\n",
            "OrderedDict([('weight', tensor([[4.9402]])), ('bias', tensor([0.8818]))])\n",
            "Loss: 0.17733339965343475\n",
            "OrderedDict([('weight', tensor([[4.9401]])), ('bias', tensor([0.8821]))])\n",
            "Loss: 0.17731976509094238\n",
            "OrderedDict([('weight', tensor([[4.9400]])), ('bias', tensor([0.8825]))])\n",
            "Loss: 0.17730587720870972\n",
            "OrderedDict([('weight', tensor([[4.9398]])), ('bias', tensor([0.8829]))])\n",
            "Loss: 0.17729179561138153\n",
            "OrderedDict([('weight', tensor([[4.9397]])), ('bias', tensor([0.8832]))])\n",
            "Loss: 0.17727820575237274\n",
            "OrderedDict([('weight', tensor([[4.9396]])), ('bias', tensor([0.8836]))])\n",
            "Epoch 25, Loss: 0.17727820575237274\n",
            "Loss: 0.17726461589336395\n",
            "OrderedDict([('weight', tensor([[4.9395]])), ('bias', tensor([0.8839]))])\n",
            "Loss: 0.1772509217262268\n",
            "OrderedDict([('weight', tensor([[4.9394]])), ('bias', tensor([0.8843]))])\n",
            "Loss: 0.17723743617534637\n",
            "OrderedDict([('weight', tensor([[4.9393]])), ('bias', tensor([0.8846]))])\n",
            "Loss: 0.177224263548851\n",
            "OrderedDict([('weight', tensor([[4.9391]])), ('bias', tensor([0.8849]))])\n",
            "Loss: 0.17721092700958252\n",
            "OrderedDict([('weight', tensor([[4.9390]])), ('bias', tensor([0.8853]))])\n",
            "Loss: 0.17719754576683044\n",
            "OrderedDict([('weight', tensor([[4.9389]])), ('bias', tensor([0.8856]))])\n",
            "Loss: 0.17718423902988434\n",
            "OrderedDict([('weight', tensor([[4.9388]])), ('bias', tensor([0.8860]))])\n",
            "Loss: 0.17717131972312927\n",
            "OrderedDict([('weight', tensor([[4.9387]])), ('bias', tensor([0.8863]))])\n",
            "Loss: 0.17715837061405182\n",
            "OrderedDict([('weight', tensor([[4.9386]])), ('bias', tensor([0.8867]))])\n",
            "Loss: 0.17714545130729675\n",
            "OrderedDict([('weight', tensor([[4.9384]])), ('bias', tensor([0.8870]))])\n",
            "Loss: 0.1771329641342163\n",
            "OrderedDict([('weight', tensor([[4.9383]])), ('bias', tensor([0.8873]))])\n",
            "Loss: 0.17712023854255676\n",
            "OrderedDict([('weight', tensor([[4.9382]])), ('bias', tensor([0.8877]))])\n",
            "Loss: 0.17710717022418976\n",
            "OrderedDict([('weight', tensor([[4.9381]])), ('bias', tensor([0.8880]))])\n",
            "Loss: 0.17709477245807648\n",
            "OrderedDict([('weight', tensor([[4.9380]])), ('bias', tensor([0.8883]))])\n",
            "Loss: 0.17708243429660797\n",
            "OrderedDict([('weight', tensor([[4.9379]])), ('bias', tensor([0.8887]))])\n",
            "Loss: 0.17706963419914246\n",
            "OrderedDict([('weight', tensor([[4.9378]])), ('bias', tensor([0.8890]))])\n",
            "Loss: 0.17705760896205902\n",
            "OrderedDict([('weight', tensor([[4.9376]])), ('bias', tensor([0.8893]))])\n",
            "Loss: 0.17704512178897858\n",
            "OrderedDict([('weight', tensor([[4.9375]])), ('bias', tensor([0.8897]))])\n",
            "Loss: 0.17703291773796082\n",
            "OrderedDict([('weight', tensor([[4.9374]])), ('bias', tensor([0.8900]))])\n",
            "Loss: 0.17702072858810425\n",
            "OrderedDict([('weight', tensor([[4.9373]])), ('bias', tensor([0.8903]))])\n",
            "Loss: 0.17700865864753723\n",
            "OrderedDict([('weight', tensor([[4.9372]])), ('bias', tensor([0.8907]))])\n",
            "Loss: 0.17699629068374634\n",
            "OrderedDict([('weight', tensor([[4.9371]])), ('bias', tensor([0.8910]))])\n",
            "Loss: 0.17698490619659424\n",
            "OrderedDict([('weight', tensor([[4.9370]])), ('bias', tensor([0.8913]))])\n",
            "Loss: 0.17697317898273468\n",
            "OrderedDict([('weight', tensor([[4.9369]])), ('bias', tensor([0.8916]))])\n"
          ]
        }
      ],
      "source": [
        "# training loop\n",
        "\n",
        "for epoch in range(50):\n",
        "    y_pred = model(X) # Forward pass\n",
        "\n",
        "    # loss = loss_fn(y_pred, y_train) \n",
        "    loss = torch.mean((y_pred - y)**2) # mean squared error loss calculation\n",
        "    print(f\"Loss: {loss}\")\n",
        "\n",
        "    # Backward pass and optimization - I\n",
        "    optimizer.zero_grad() # optimizer\n",
        "    loss.backward() # back propagation on loss\n",
        "    optimizer.step() # optimizer ->SGD\n",
        "\n",
        "    print(model.state_dict())\n",
        "\n",
        "    # Testing\n",
        "    \"\"\"\n",
        "    model.eval()\n",
        "    with torch.inference_mode():\n",
        "        test_pred = model(X_test)\n",
        "        test_loss = loss_fn(test_pred, y_test)\n",
        "    \"\"\"\n",
        "    # Print the loss every 5 epochs\n",
        "    if epoch % 25 == 0:\n",
        "        print(f\"Epoch {epoch}, Loss: {loss.item()}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KDf48Fx4gn03"
      },
      "source": [
        "Model testing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V4mwDnZRe-9z"
      },
      "outputs": [],
      "source": [
        "X_test = torch.tensor([[5.0], [6.0], [10.0], [11.0]])\n",
        "y_test_pred = model(X_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mEsaTzcJfBv6",
        "outputId": "89038762-8491-4732-97de-311ddd5aae4c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor([[25.5759],\n",
            "        [30.5128],\n",
            "        [50.2602],\n",
            "        [55.1971]], grad_fn=<AddmmBackward0>)\n"
          ]
        }
      ],
      "source": [
        "print(y_test_pred)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ypxE5AGgj815",
        "outputId": "ab239707-928b-49f5-9a5a-fce81bf93a03"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor([[25.5882],\n",
            "        [30.5310],\n",
            "        [50.3023],\n",
            "        [55.2451]], grad_fn=<AddmmBackward0>)\n"
          ]
        }
      ],
      "source": [
        "print(y_test_pred) # model = torch.nn.Linear(1, 10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZdbzB4WwYhcZ",
        "outputId": "c2f81014-fb22-48db-b717-6a7a4c6d669c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "OrderedDict([('weight', tensor([[4.9369]])), ('bias', tensor([0.8916]))])"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.state_dict()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "authorship_tag": "ABX9TyO7ITdv+ZEG2AK1AdolUigs",
      "gpuType": "T4",
      "include_colab_link": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}