01_pytorch_workflow_codealong.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/innovinitylabs/learning-pytorch/blob/main/01_pytorch_workflow_codealong.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "9iicrKm4IVjD",
        "outputId": "403117b3-0cb6-47bf-b089-fdcbb4e0f20b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'2.1.0'"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "torch.__version__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g27FjDsREmQS"
      },
      "source": [
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "tVkgHFJWEmjj"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.0000],\n",
              "        [0.0200],\n",
              "        [0.0400],\n",
              "        [0.0600],\n",
              "        [0.0800],\n",
              "        [0.1000],\n",
              "        [0.1200],\n",
              "        [0.1400],\n",
              "        [0.1600],\n",
              "        [0.1800],\n",
              "        [0.2000],\n",
              "        [0.2200],\n",
              "        [0.2400],\n",
              "        [0.2600],\n",
              "        [0.2800],\n",
              "        [0.3000],\n",
              "        [0.3200],\n",
              "        [0.3400],\n",
              "        [0.3600],\n",
              "        [0.3800],\n",
              "        [0.4000],\n",
              "        [0.4200],\n",
              "        [0.4400],\n",
              "        [0.4600],\n",
              "        [0.4800],\n",
              "        [0.5000],\n",
              "        [0.5200],\n",
              "        [0.5400],\n",
              "        [0.5600],\n",
              "        [0.5800],\n",
              "        [0.6000],\n",
              "        [0.6200],\n",
              "        [0.6400],\n",
              "        [0.6600],\n",
              "        [0.6800],\n",
              "        [0.7000],\n",
              "        [0.7200],\n",
              "        [0.7400],\n",
              "        [0.7600],\n",
              "        [0.7800],\n",
              "        [0.8000],\n",
              "        [0.8200],\n",
              "        [0.8400],\n",
              "        [0.8600],\n",
              "        [0.8800],\n",
              "        [0.9000],\n",
              "        [0.9200],\n",
              "        [0.9400],\n",
              "        [0.9600],\n",
              "        [0.9800]])"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "weight = 0.7\n",
        "bias = 0.3 # weight and bias are known parameters\n",
        "\n",
        "start = 0\n",
        "end = 1\n",
        "step = 0.02\n",
        "\n",
        "X = torch.arange(start, end, step).unsqueeze(dim= 1)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "InXMbb4jGDM3",
        "outputId": "62554896-04f5-4909-aee9-cd0e43ac947d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.0000, 0.0200, 0.0400, 0.0600, 0.0800, 0.1000, 0.1200, 0.1400, 0.1600,\n",
              "         0.1800, 0.2000, 0.2200, 0.2400, 0.2600, 0.2800, 0.3000, 0.3200, 0.3400,\n",
              "         0.3600, 0.3800, 0.4000, 0.4200, 0.4400, 0.4600, 0.4800, 0.5000, 0.5200,\n",
              "         0.5400, 0.5600, 0.5800, 0.6000, 0.6200, 0.6400, 0.6600, 0.6800, 0.7000,\n",
              "         0.7200, 0.7400, 0.7600, 0.7800, 0.8000, 0.8200, 0.8400, 0.8600, 0.8800,\n",
              "         0.9000, 0.9200, 0.9400, 0.9600, 0.9800]])"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.arange(start, end, step).unsqueeze(dim = 0)[:10]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YI1FJCb2GGmA",
        "outputId": "b69de093-1f6c-40cf-b3a6-021cd02a40dd"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.0000],\n",
              "        [0.0200],\n",
              "        [0.0400],\n",
              "        [0.0600],\n",
              "        [0.0800],\n",
              "        [0.1000],\n",
              "        [0.1200],\n",
              "        [0.1400],\n",
              "        [0.1600],\n",
              "        [0.1800]])"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.arange(start, end, step).unsqueeze(dim = -1)[:10]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1JtZ5awUGO0C",
        "outputId": "b32e7711-2a87-496a-bf2d-7439d4d55094"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.0000, 0.0200, 0.0400, 0.0600, 0.0800, 0.1000, 0.1200, 0.1400, 0.1600,\n",
              "         0.1800, 0.2000, 0.2200, 0.2400, 0.2600, 0.2800, 0.3000, 0.3200, 0.3400,\n",
              "         0.3600, 0.3800, 0.4000, 0.4200, 0.4400, 0.4600, 0.4800, 0.5000, 0.5200,\n",
              "         0.5400, 0.5600, 0.5800, 0.6000, 0.6200, 0.6400, 0.6600, 0.6800, 0.7000,\n",
              "         0.7200, 0.7400, 0.7600, 0.7800, 0.8000, 0.8200, 0.8400, 0.8600, 0.8800,\n",
              "         0.9000, 0.9200, 0.9400, 0.9600, 0.9800]])"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.arange(start, end, step).unsqueeze(dim = -2)[:10]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "40txHyrMG6Ee"
      },
      "outputs": [],
      "source": [
        "y = weight * X + bias"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AfYzODJvHCDm",
        "outputId": "17233f04-e87a-4568-8793-7554eb6fc0da"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[0.0000],\n",
              "         [0.0200],\n",
              "         [0.0400],\n",
              "         [0.0600],\n",
              "         [0.0800],\n",
              "         [0.1000],\n",
              "         [0.1200],\n",
              "         [0.1400],\n",
              "         [0.1600],\n",
              "         [0.1800]]),\n",
              " tensor([[0.3000],\n",
              "         [0.3140],\n",
              "         [0.3280],\n",
              "         [0.3420],\n",
              "         [0.3560],\n",
              "         [0.3700],\n",
              "         [0.3840],\n",
              "         [0.3980],\n",
              "         [0.4120],\n",
              "         [0.4260]]))"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X[:10], y[:10]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xpxe5wQcHsyA",
        "outputId": "1d6921e3-9183-4066-a91c-2ab5f71a0eaa"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(50, 50)"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(X), len(y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YUuR2rLl_ggt",
        "outputId": "278be613-2133-4fae-ca04-f7b5d056da86"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "train_samp = int(.8 * len(X))\n",
        "X_train, y_train = X[:train_samp], y[:train_samp]\n",
        "X_test, y_test = X[train_samp:], y[train_samp:]\n",
        "\n",
        "len(X_train),len(y_train),len(X_test),len(y_test),"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KLF6KcInCYVY"
      },
      "source": [
        "to visualise data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "9IduqDNvCais"
      },
      "outputs": [],
      "source": [
        "def plot_pred(train_data= X_train, train_labels= y_train,\n",
        "              test_data= X_test, test_labels= y_test,\n",
        "              predictions= None):\n",
        "  plt.figure(figsize=(10,7))\n",
        "\n",
        "  plt.scatter(train_data, train_labels, c='b', s=4, label='Training Data')\n",
        "\n",
        "  plt.scatter(test_data, test_labels, c='g', s=4, label='Test Data')\n",
        "\n",
        "  if predictions is not None:\n",
        "    plt.scatter(test_data, predictions, c='r', s=4, label='Prediction')\n",
        "\n",
        "  plt.legend(prop={'size': 14})\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "xF5hgrBiFCbN",
        "outputId": "2f91c72e-a823-4fdc-a7af-68dbb50ed88b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_pred()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lkmvZ2g2HVyA"
      },
      "source": [
        "## building first pytorch model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "eCwO4lJcHYjp"
      },
      "outputs": [],
      "source": [
        "class LinearRegressionModel(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "\n",
        "    self.weights = nn.Parameter(torch.randn(1, requires_grad=True, dtype=torch.float))\n",
        "    self.bias = nn.Parameter(torch.randn(1, requires_grad=True, dtype=torch.float))\n",
        "\n",
        "    #forward method\n",
        "  def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
        "    return self.weights * x + self.bias\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([0.3367], requires_grad=True),\n",
              " Parameter containing:\n",
              " tensor([0.1288], requires_grad=True)]"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "model_0 = LinearRegressionModel()\n",
        "\n",
        "list(model_0.parameters())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_0.state_dict()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "makign predictions with inference mode"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.3982],\n",
              "        [0.4049],\n",
              "        [0.4116],\n",
              "        [0.4184],\n",
              "        [0.4251],\n",
              "        [0.4318],\n",
              "        [0.4386],\n",
              "        [0.4453],\n",
              "        [0.4520],\n",
              "        [0.4588]], grad_fn=<AddBackward0>)"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y2_pred = model_0(X_test) #this uses grad\n",
        "y2_pred"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[0.3982],\n",
              "         [0.4049],\n",
              "         [0.4116],\n",
              "         [0.4184],\n",
              "         [0.4251],\n",
              "         [0.4318],\n",
              "         [0.4386],\n",
              "         [0.4453],\n",
              "         [0.4520],\n",
              "         [0.4588]]),\n",
              " tensor([[0.8600],\n",
              "         [0.8740],\n",
              "         [0.8880],\n",
              "         [0.9020],\n",
              "         [0.9160],\n",
              "         [0.9300],\n",
              "         [0.9440],\n",
              "         [0.9580],\n",
              "         [0.9720],\n",
              "         [0.9860]]))"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "with torch.inference_mode():\n",
        "    y_pred = model_0(X_test)\n",
        "\n",
        "y_pred , y_test"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "this is to make the prediction run faster without using fancy things like grad. we can also use torch.nograd()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_pred(predictions=y_pred)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "setting up loss functions (mean absolute error here)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [],
      "source": [
        "loss_fn = nn.L1Loss()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "setting up optimiser (we use sgd here)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [],
      "source": [
        "opti = torch.optim.SGD(params=model_0.parameters(), lr=0.001)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "building a training loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "epoch: 0, test loss: 0.4931890368461609, loss: 0.31288138031959534\n",
            "OrderedDict([('weights', tensor([0.3371])), ('bias', tensor([0.1298]))])\n",
            "epoch: 10, test loss: 0.4797181189060211, loss: 0.3013603389263153\n",
            "OrderedDict([('weights', tensor([0.3410])), ('bias', tensor([0.1398]))])\n",
            "epoch: 20, test loss: 0.4662471413612366, loss: 0.28983938694000244\n",
            "OrderedDict([('weights', tensor([0.3449])), ('bias', tensor([0.1498]))])\n",
            "epoch: 30, test loss: 0.4527761936187744, loss: 0.2783183455467224\n",
            "OrderedDict([('weights', tensor([0.3488])), ('bias', tensor([0.1598]))])\n",
            "epoch: 40, test loss: 0.43930521607398987, loss: 0.26679736375808716\n",
            "OrderedDict([('weights', tensor([0.3527])), ('bias', tensor([0.1698]))])\n",
            "epoch: 50, test loss: 0.4258342385292053, loss: 0.2552763819694519\n",
            "OrderedDict([('weights', tensor([0.3566])), ('bias', tensor([0.1798]))])\n",
            "epoch: 60, test loss: 0.41236335039138794, loss: 0.24375538527965546\n",
            "OrderedDict([('weights', tensor([0.3605])), ('bias', tensor([0.1898]))])\n",
            "epoch: 70, test loss: 0.398892343044281, loss: 0.232234388589859\n",
            "OrderedDict([('weights', tensor([0.3644])), ('bias', tensor([0.1998]))])\n",
            "epoch: 80, test loss: 0.38542139530181885, loss: 0.22071340680122375\n",
            "OrderedDict([('weights', tensor([0.3683])), ('bias', tensor([0.2098]))])\n",
            "epoch: 90, test loss: 0.3719504475593567, loss: 0.2091923952102661\n",
            "OrderedDict([('weights', tensor([0.3722])), ('bias', tensor([0.2198]))])\n",
            "epoch: 100, test loss: 0.35847947001457214, loss: 0.19767141342163086\n",
            "OrderedDict([('weights', tensor([0.3761])), ('bias', tensor([0.2298]))])\n",
            "epoch: 110, test loss: 0.34500852227211, loss: 0.18615040183067322\n",
            "OrderedDict([('weights', tensor([0.3800])), ('bias', tensor([0.2398]))])\n",
            "epoch: 120, test loss: 0.33153754472732544, loss: 0.17462942004203796\n",
            "OrderedDict([('weights', tensor([0.3839])), ('bias', tensor([0.2498]))])\n",
            "epoch: 130, test loss: 0.3180667459964752, loss: 0.16310855746269226\n",
            "OrderedDict([('weights', tensor([0.3878])), ('bias', tensor([0.2598]))])\n",
            "epoch: 140, test loss: 0.304595947265625, loss: 0.15158770978450775\n",
            "OrderedDict([('weights', tensor([0.3917])), ('bias', tensor([0.2698]))])\n",
            "epoch: 150, test loss: 0.2911251187324524, loss: 0.14006686210632324\n",
            "OrderedDict([('weights', tensor([0.3956])), ('bias', tensor([0.2798]))])\n",
            "epoch: 160, test loss: 0.2776543200016022, loss: 0.12854602932929993\n",
            "OrderedDict([('weights', tensor([0.3995])), ('bias', tensor([0.2898]))])\n",
            "epoch: 170, test loss: 0.26418352127075195, loss: 0.11702518165111542\n",
            "OrderedDict([('weights', tensor([0.4034])), ('bias', tensor([0.2998]))])\n",
            "epoch: 180, test loss: 0.251315176486969, loss: 0.10654275119304657\n",
            "OrderedDict([('weights', tensor([0.4073])), ('bias', tensor([0.3092]))])\n",
            "epoch: 190, test loss: 0.2392154484987259, loss: 0.09747617691755295\n",
            "OrderedDict([('weights', tensor([0.4112])), ('bias', tensor([0.3179]))])\n",
            "epoch: 200, test loss: 0.22795839607715607, loss: 0.08973254263401031\n",
            "OrderedDict([('weights', tensor([0.4150])), ('bias', tensor([0.3257]))])\n",
            "epoch: 210, test loss: 0.21740305423736572, loss: 0.08306284993886948\n",
            "OrderedDict([('weights', tensor([0.4188])), ('bias', tensor([0.3329]))])\n",
            "epoch: 220, test loss: 0.20750825107097626, loss: 0.07729282230138779\n",
            "OrderedDict([('weights', tensor([0.4225])), ('bias', tensor([0.3395]))])\n",
            "epoch: 230, test loss: 0.19840054214000702, loss: 0.07242877781391144\n",
            "OrderedDict([('weights', tensor([0.4261])), ('bias', tensor([0.3454]))])\n",
            "epoch: 240, test loss: 0.18992407619953156, loss: 0.06828799843788147\n",
            "OrderedDict([('weights', tensor([0.4296])), ('bias', tensor([0.3508]))])\n",
            "epoch: 250, test loss: 0.18208928406238556, loss: 0.06476505100727081\n",
            "OrderedDict([('weights', tensor([0.4330])), ('bias', tensor([0.3556]))])\n",
            "epoch: 260, test loss: 0.17478716373443604, loss: 0.06174134090542793\n",
            "OrderedDict([('weights', tensor([0.4363])), ('bias', tensor([0.3599]))])\n",
            "epoch: 270, test loss: 0.16802480816841125, loss: 0.05915876105427742\n",
            "OrderedDict([('weights', tensor([0.4395])), ('bias', tensor([0.3638]))])\n",
            "epoch: 280, test loss: 0.161748006939888, loss: 0.0569603256881237\n",
            "OrderedDict([('weights', tensor([0.4426])), ('bias', tensor([0.3673]))])\n",
            "epoch: 290, test loss: 0.15608695149421692, loss: 0.05514555424451828\n",
            "OrderedDict([('weights', tensor([0.4456])), ('bias', tensor([0.3703]))])\n",
            "epoch: 300, test loss: 0.15086300671100616, loss: 0.053577303886413574\n",
            "OrderedDict([('weights', tensor([0.4485])), ('bias', tensor([0.3730]))])\n",
            "epoch: 310, test loss: 0.14595307409763336, loss: 0.05218071490526199\n",
            "OrderedDict([('weights', tensor([0.4513])), ('bias', tensor([0.3754]))])\n",
            "epoch: 320, test loss: 0.1415499746799469, loss: 0.05105169489979744\n",
            "OrderedDict([('weights', tensor([0.4540])), ('bias', tensor([0.3774]))])\n",
            "epoch: 330, test loss: 0.1374681293964386, loss: 0.050030313432216644\n",
            "OrderedDict([('weights', tensor([0.4567])), ('bias', tensor([0.3791]))])\n",
            "epoch: 340, test loss: 0.13370750844478607, loss: 0.049160148948431015\n",
            "OrderedDict([('weights', tensor([0.4592])), ('bias', tensor([0.3806]))])\n",
            "epoch: 350, test loss: 0.13020753860473633, loss: 0.04836020618677139\n",
            "OrderedDict([('weights', tensor([0.4617])), ('bias', tensor([0.3819]))])\n",
            "epoch: 360, test loss: 0.12709848582744598, loss: 0.04769856110215187\n",
            "OrderedDict([('weights', tensor([0.4640])), ('bias', tensor([0.3829]))])\n",
            "epoch: 370, test loss: 0.12398938834667206, loss: 0.04703690484166145\n",
            "OrderedDict([('weights', tensor([0.4664])), ('bias', tensor([0.3839]))])\n",
            "epoch: 380, test loss: 0.12147434055805206, loss: 0.046500932425260544\n",
            "OrderedDict([('weights', tensor([0.4686])), ('bias', tensor([0.3845]))])\n",
            "epoch: 390, test loss: 0.11902527511119843, loss: 0.045996345579624176\n",
            "OrderedDict([('weights', tensor([0.4708])), ('bias', tensor([0.3850]))])\n",
            "epoch: 400, test loss: 0.11657620966434479, loss: 0.04549176245927811\n",
            "OrderedDict([('weights', tensor([0.4730])), ('bias', tensor([0.3855]))])\n",
            "epoch: 410, test loss: 0.11432783305644989, loss: 0.045014552772045135\n",
            "OrderedDict([('weights', tensor([0.4751])), ('bias', tensor([0.3858]))])\n",
            "epoch: 420, test loss: 0.11254779994487762, loss: 0.04461454600095749\n",
            "OrderedDict([('weights', tensor([0.4771])), ('bias', tensor([0.3858]))])\n",
            "epoch: 430, test loss: 0.11076776683330536, loss: 0.04421453922986984\n",
            "OrderedDict([('weights', tensor([0.4791])), ('bias', tensor([0.3858]))])\n",
            "epoch: 440, test loss: 0.1089877337217331, loss: 0.043814532458782196\n",
            "OrderedDict([('weights', tensor([0.4811])), ('bias', tensor([0.3858]))])\n",
            "epoch: 450, test loss: 0.10720770061016083, loss: 0.04341452196240425\n",
            "OrderedDict([('weights', tensor([0.4831])), ('bias', tensor([0.3858]))])\n",
            "epoch: 460, test loss: 0.10542766749858856, loss: 0.04301450774073601\n",
            "OrderedDict([('weights', tensor([0.4851])), ('bias', tensor([0.3858]))])\n",
            "epoch: 470, test loss: 0.10419009625911713, loss: 0.04265119880437851\n",
            "OrderedDict([('weights', tensor([0.4870])), ('bias', tensor([0.3854]))])\n",
            "epoch: 480, test loss: 0.1030881255865097, loss: 0.04230218380689621\n",
            "OrderedDict([('weights', tensor([0.4888])), ('bias', tensor([0.3849]))])\n",
            "epoch: 490, test loss: 0.10198615491390228, loss: 0.04195316880941391\n",
            "OrderedDict([('weights', tensor([0.4906])), ('bias', tensor([0.3844]))])\n",
            "epoch: 500, test loss: 0.10088418424129486, loss: 0.04160415381193161\n",
            "OrderedDict([('weights', tensor([0.4924])), ('bias', tensor([0.3839]))])\n",
            "epoch: 510, test loss: 0.09978221356868744, loss: 0.04125513881444931\n",
            "OrderedDict([('weights', tensor([0.4942])), ('bias', tensor([0.3834]))])\n",
            "epoch: 520, test loss: 0.09868024289608002, loss: 0.04090612381696701\n",
            "OrderedDict([('weights', tensor([0.4960])), ('bias', tensor([0.3829]))])\n",
            "epoch: 530, test loss: 0.0975782722234726, loss: 0.04055710881948471\n",
            "OrderedDict([('weights', tensor([0.4978])), ('bias', tensor([0.3824]))])\n",
            "epoch: 540, test loss: 0.09647630155086517, loss: 0.04020809382200241\n",
            "OrderedDict([('weights', tensor([0.4996])), ('bias', tensor([0.3819]))])\n",
            "epoch: 550, test loss: 0.09537436813116074, loss: 0.03985908254981041\n",
            "OrderedDict([('weights', tensor([0.5014])), ('bias', tensor([0.3814]))])\n",
            "epoch: 560, test loss: 0.09427239745855331, loss: 0.03951007127761841\n",
            "OrderedDict([('weights', tensor([0.5032])), ('bias', tensor([0.3809]))])\n",
            "epoch: 570, test loss: 0.09317042678594589, loss: 0.03916105255484581\n",
            "OrderedDict([('weights', tensor([0.5050])), ('bias', tensor([0.3804]))])\n",
            "epoch: 580, test loss: 0.09206845611333847, loss: 0.03881204128265381\n",
            "OrderedDict([('weights', tensor([0.5068])), ('bias', tensor([0.3799]))])\n",
            "epoch: 590, test loss: 0.09096648544073105, loss: 0.03846302255988121\n",
            "OrderedDict([('weights', tensor([0.5086])), ('bias', tensor([0.3794]))])\n",
            "epoch: 600, test loss: 0.08986451476812363, loss: 0.03811401128768921\n",
            "OrderedDict([('weights', tensor([0.5104])), ('bias', tensor([0.3789]))])\n",
            "epoch: 610, test loss: 0.0887625440955162, loss: 0.03776499256491661\n",
            "OrderedDict([('weights', tensor([0.5122])), ('bias', tensor([0.3784]))])\n",
            "epoch: 620, test loss: 0.08766057342290878, loss: 0.03741598129272461\n",
            "OrderedDict([('weights', tensor([0.5140])), ('bias', tensor([0.3779]))])\n",
            "epoch: 630, test loss: 0.08662726730108261, loss: 0.037067197263240814\n",
            "OrderedDict([('weights', tensor([0.5157])), ('bias', tensor([0.3774]))])\n",
            "epoch: 640, test loss: 0.08579986542463303, loss: 0.03672432899475098\n",
            "OrderedDict([('weights', tensor([0.5175])), ('bias', tensor([0.3767]))])\n",
            "epoch: 650, test loss: 0.08497253060340881, loss: 0.03638043254613876\n",
            "OrderedDict([('weights', tensor([0.5192])), ('bias', tensor([0.3760]))])\n",
            "epoch: 660, test loss: 0.08421380817890167, loss: 0.036036938428878784\n",
            "OrderedDict([('weights', tensor([0.5209])), ('bias', tensor([0.3752]))])\n",
            "epoch: 670, test loss: 0.08338643610477448, loss: 0.03569390997290611\n",
            "OrderedDict([('weights', tensor([0.5226])), ('bias', tensor([0.3745]))])\n",
            "epoch: 680, test loss: 0.08255907148122787, loss: 0.035350002348423004\n",
            "OrderedDict([('weights', tensor([0.5243])), ('bias', tensor([0.3738]))])\n",
            "epoch: 690, test loss: 0.08180035650730133, loss: 0.035006679594516754\n",
            "OrderedDict([('weights', tensor([0.5260])), ('bias', tensor([0.3731]))])\n",
            "epoch: 700, test loss: 0.08097299933433533, loss: 0.03466346859931946\n",
            "OrderedDict([('weights', tensor([0.5277])), ('bias', tensor([0.3724]))])\n",
            "epoch: 710, test loss: 0.08014564216136932, loss: 0.03431956097483635\n",
            "OrderedDict([('weights', tensor([0.5294])), ('bias', tensor([0.3717]))])\n",
            "epoch: 720, test loss: 0.07938691228628159, loss: 0.03397642448544502\n",
            "OrderedDict([('weights', tensor([0.5311])), ('bias', tensor([0.3709]))])\n",
            "epoch: 730, test loss: 0.07855955511331558, loss: 0.0336330309510231\n",
            "OrderedDict([('weights', tensor([0.5328])), ('bias', tensor([0.3702]))])\n",
            "epoch: 740, test loss: 0.07773219794034958, loss: 0.03328912705183029\n",
            "OrderedDict([('weights', tensor([0.5346])), ('bias', tensor([0.3695]))])\n",
            "epoch: 750, test loss: 0.07697348296642303, loss: 0.032946161925792694\n",
            "OrderedDict([('weights', tensor([0.5363])), ('bias', tensor([0.3688]))])\n",
            "epoch: 760, test loss: 0.07614611089229584, loss: 0.032602597028017044\n",
            "OrderedDict([('weights', tensor([0.5380])), ('bias', tensor([0.3681]))])\n",
            "epoch: 770, test loss: 0.07538740336894989, loss: 0.0322587676346302\n",
            "OrderedDict([('weights', tensor([0.5397])), ('bias', tensor([0.3673]))])\n",
            "epoch: 780, test loss: 0.07456003129482269, loss: 0.031915903091430664\n",
            "OrderedDict([('weights', tensor([0.5414])), ('bias', tensor([0.3666]))])\n",
            "epoch: 790, test loss: 0.07373266667127609, loss: 0.031572163105010986\n",
            "OrderedDict([('weights', tensor([0.5431])), ('bias', tensor([0.3659]))])\n",
            "epoch: 800, test loss: 0.07297395914793015, loss: 0.03122851625084877\n",
            "OrderedDict([('weights', tensor([0.5448])), ('bias', tensor([0.3652]))])\n",
            "epoch: 810, test loss: 0.07214658707380295, loss: 0.03088562563061714\n",
            "OrderedDict([('weights', tensor([0.5465])), ('bias', tensor([0.3645]))])\n",
            "epoch: 820, test loss: 0.07131922990083694, loss: 0.03054172359406948\n",
            "OrderedDict([('weights', tensor([0.5482])), ('bias', tensor([0.3638]))])\n",
            "epoch: 830, test loss: 0.0705605149269104, loss: 0.030198251828551292\n",
            "OrderedDict([('weights', tensor([0.5499])), ('bias', tensor([0.3630]))])\n",
            "epoch: 840, test loss: 0.0697331428527832, loss: 0.029855191707611084\n",
            "OrderedDict([('weights', tensor([0.5516])), ('bias', tensor([0.3623]))])\n",
            "epoch: 850, test loss: 0.0689057856798172, loss: 0.029511287808418274\n",
            "OrderedDict([('weights', tensor([0.5534])), ('bias', tensor([0.3616]))])\n",
            "epoch: 860, test loss: 0.06814707070589066, loss: 0.02916799858212471\n",
            "OrderedDict([('weights', tensor([0.5551])), ('bias', tensor([0.3609]))])\n",
            "epoch: 870, test loss: 0.06731969118118286, loss: 0.028824755921959877\n",
            "OrderedDict([('weights', tensor([0.5568])), ('bias', tensor([0.3602]))])\n",
            "epoch: 880, test loss: 0.06649234890937805, loss: 0.028480852022767067\n",
            "OrderedDict([('weights', tensor([0.5585])), ('bias', tensor([0.3595]))])\n",
            "epoch: 890, test loss: 0.06573362648487091, loss: 0.02813773788511753\n",
            "OrderedDict([('weights', tensor([0.5602])), ('bias', tensor([0.3587]))])\n",
            "epoch: 900, test loss: 0.06490625441074371, loss: 0.027794327586889267\n",
            "OrderedDict([('weights', tensor([0.5619])), ('bias', tensor([0.3580]))])\n",
            "epoch: 910, test loss: 0.06407888978719711, loss: 0.02745041809976101\n",
            "OrderedDict([('weights', tensor([0.5636])), ('bias', tensor([0.3573]))])\n",
            "epoch: 920, test loss: 0.06332017481327057, loss: 0.0271074827760458\n",
            "OrderedDict([('weights', tensor([0.5653])), ('bias', tensor([0.3566]))])\n",
            "epoch: 930, test loss: 0.062492817640304565, loss: 0.026763886213302612\n",
            "OrderedDict([('weights', tensor([0.5670])), ('bias', tensor([0.3559]))])\n",
            "epoch: 940, test loss: 0.06173409894108772, loss: 0.02642008289694786\n",
            "OrderedDict([('weights', tensor([0.5687])), ('bias', tensor([0.3551]))])\n",
            "epoch: 950, test loss: 0.06090673804283142, loss: 0.02607722207903862\n",
            "OrderedDict([('weights', tensor([0.5704])), ('bias', tensor([0.3544]))])\n",
            "epoch: 960, test loss: 0.06007937341928482, loss: 0.025733450427651405\n",
            "OrderedDict([('weights', tensor([0.5721])), ('bias', tensor([0.3537]))])\n",
            "epoch: 970, test loss: 0.05932066589593887, loss: 0.02538982965052128\n",
            "OrderedDict([('weights', tensor([0.5738])), ('bias', tensor([0.3530]))])\n",
            "epoch: 980, test loss: 0.058493297547101974, loss: 0.025046909227967262\n",
            "OrderedDict([('weights', tensor([0.5756])), ('bias', tensor([0.3523]))])\n",
            "epoch: 990, test loss: 0.057665932923555374, loss: 0.0247030109167099\n",
            "OrderedDict([('weights', tensor([0.5773])), ('bias', tensor([0.3516]))])\n",
            "epoch: 1000, test loss: 0.05690721794962883, loss: 0.02435957081615925\n",
            "OrderedDict([('weights', tensor([0.5790])), ('bias', tensor([0.3508]))])\n",
            "epoch: 1010, test loss: 0.05607985332608223, loss: 0.024016480892896652\n",
            "OrderedDict([('weights', tensor([0.5807])), ('bias', tensor([0.3501]))])\n",
            "epoch: 1020, test loss: 0.055252473801374435, loss: 0.02367258071899414\n",
            "OrderedDict([('weights', tensor([0.5824])), ('bias', tensor([0.3494]))])\n",
            "epoch: 1030, test loss: 0.054493773728609085, loss: 0.023329313844442368\n",
            "OrderedDict([('weights', tensor([0.5841])), ('bias', tensor([0.3487]))])\n",
            "epoch: 1040, test loss: 0.05366641283035278, loss: 0.022986043244600296\n",
            "OrderedDict([('weights', tensor([0.5858])), ('bias', tensor([0.3480]))])\n",
            "epoch: 1050, test loss: 0.05283904820680618, loss: 0.022642139345407486\n",
            "OrderedDict([('weights', tensor([0.5875])), ('bias', tensor([0.3473]))])\n",
            "epoch: 1060, test loss: 0.05208033323287964, loss: 0.02229905314743519\n",
            "OrderedDict([('weights', tensor([0.5892])), ('bias', tensor([0.3465]))])\n",
            "epoch: 1070, test loss: 0.05125296115875244, loss: 0.02195560745894909\n",
            "OrderedDict([('weights', tensor([0.5909])), ('bias', tensor([0.3458]))])\n",
            "epoch: 1080, test loss: 0.05042559653520584, loss: 0.021611705422401428\n",
            "OrderedDict([('weights', tensor([0.5927])), ('bias', tensor([0.3451]))])\n",
            "epoch: 1090, test loss: 0.0496668815612793, loss: 0.021268798038363457\n",
            "OrderedDict([('weights', tensor([0.5944])), ('bias', tensor([0.3444]))])\n",
            "epoch: 1100, test loss: 0.0488395169377327, loss: 0.02092517539858818\n",
            "OrderedDict([('weights', tensor([0.5961])), ('bias', tensor([0.3437]))])\n",
            "epoch: 1110, test loss: 0.04808080196380615, loss: 0.020581405609846115\n",
            "OrderedDict([('weights', tensor([0.5978])), ('bias', tensor([0.3429]))])\n",
            "epoch: 1120, test loss: 0.047253452241420746, loss: 0.020238537341356277\n",
            "OrderedDict([('weights', tensor([0.5995])), ('bias', tensor([0.3422]))])\n",
            "epoch: 1130, test loss: 0.04642607644200325, loss: 0.01989474520087242\n",
            "OrderedDict([('weights', tensor([0.6012])), ('bias', tensor([0.3415]))])\n",
            "epoch: 1140, test loss: 0.0456673689186573, loss: 0.019551148638129234\n",
            "OrderedDict([('weights', tensor([0.6029])), ('bias', tensor([0.3408]))])\n",
            "epoch: 1150, test loss: 0.04483998939394951, loss: 0.019208211451768875\n",
            "OrderedDict([('weights', tensor([0.6046])), ('bias', tensor([0.3401]))])\n",
            "epoch: 1160, test loss: 0.044012635946273804, loss: 0.018864300101995468\n",
            "OrderedDict([('weights', tensor([0.6063])), ('bias', tensor([0.3394]))])\n",
            "epoch: 1170, test loss: 0.04325391724705696, loss: 0.018520886078476906\n",
            "OrderedDict([('weights', tensor([0.6080])), ('bias', tensor([0.3386]))])\n",
            "epoch: 1180, test loss: 0.04242655634880066, loss: 0.01817776821553707\n",
            "OrderedDict([('weights', tensor([0.6097])), ('bias', tensor([0.3379]))])\n",
            "epoch: 1190, test loss: 0.04159919545054436, loss: 0.01783386431634426\n",
            "OrderedDict([('weights', tensor([0.6115])), ('bias', tensor([0.3372]))])\n",
            "epoch: 1200, test loss: 0.04084048420190811, loss: 0.017490629106760025\n",
            "OrderedDict([('weights', tensor([0.6131])), ('bias', tensor([0.3365]))])\n",
            "epoch: 1210, test loss: 0.040013112127780914, loss: 0.017147328704595566\n",
            "OrderedDict([('weights', tensor([0.6149])), ('bias', tensor([0.3358]))])\n",
            "epoch: 1220, test loss: 0.03918575122952461, loss: 0.016803428530693054\n",
            "OrderedDict([('weights', tensor([0.6166])), ('bias', tensor([0.3351]))])\n",
            "epoch: 1230, test loss: 0.03842703625559807, loss: 0.016460372135043144\n",
            "OrderedDict([('weights', tensor([0.6183])), ('bias', tensor([0.3343]))])\n",
            "epoch: 1240, test loss: 0.03759966418147087, loss: 0.016116898506879807\n",
            "OrderedDict([('weights', tensor([0.6200])), ('bias', tensor([0.3336]))])\n",
            "epoch: 1250, test loss: 0.036772288382053375, loss: 0.015772998332977295\n",
            "OrderedDict([('weights', tensor([0.6217])), ('bias', tensor([0.3329]))])\n",
            "epoch: 1260, test loss: 0.03601359575986862, loss: 0.01543011236935854\n",
            "OrderedDict([('weights', tensor([0.6234])), ('bias', tensor([0.3322]))])\n",
            "epoch: 1270, test loss: 0.03518623113632202, loss: 0.015086461789906025\n",
            "OrderedDict([('weights', tensor([0.6251])), ('bias', tensor([0.3315]))])\n",
            "epoch: 1280, test loss: 0.03442750498652458, loss: 0.014742719009518623\n",
            "OrderedDict([('weights', tensor([0.6268])), ('bias', tensor([0.3307]))])\n",
            "epoch: 1290, test loss: 0.03360014408826828, loss: 0.01439985167235136\n",
            "OrderedDict([('weights', tensor([0.6285])), ('bias', tensor([0.3300]))])\n",
            "epoch: 1300, test loss: 0.03277278691530228, loss: 0.014056026935577393\n",
            "OrderedDict([('weights', tensor([0.6302])), ('bias', tensor([0.3293]))])\n",
            "epoch: 1310, test loss: 0.03201407939195633, loss: 0.013712461106479168\n",
            "OrderedDict([('weights', tensor([0.6319])), ('bias', tensor([0.3286]))])\n",
            "epoch: 1320, test loss: 0.031186699867248535, loss: 0.013369495049118996\n",
            "OrderedDict([('weights', tensor([0.6337])), ('bias', tensor([0.3279]))])\n",
            "epoch: 1330, test loss: 0.030359338968992233, loss: 0.01302559394389391\n",
            "OrderedDict([('weights', tensor([0.6354])), ('bias', tensor([0.3272]))])\n",
            "epoch: 1340, test loss: 0.029600614681839943, loss: 0.012682202272117138\n",
            "OrderedDict([('weights', tensor([0.6371])), ('bias', tensor([0.3264]))])\n",
            "epoch: 1350, test loss: 0.028773266822099686, loss: 0.012339058332145214\n",
            "OrderedDict([('weights', tensor([0.6388])), ('bias', tensor([0.3257]))])\n",
            "epoch: 1360, test loss: 0.02794589474797249, loss: 0.011995161883533001\n",
            "OrderedDict([('weights', tensor([0.6405])), ('bias', tensor([0.3250]))])\n",
            "epoch: 1370, test loss: 0.02718718722462654, loss: 0.011651947163045406\n",
            "OrderedDict([('weights', tensor([0.6422])), ('bias', tensor([0.3243]))])\n",
            "epoch: 1380, test loss: 0.026359815150499344, loss: 0.011308629997074604\n",
            "OrderedDict([('weights', tensor([0.6439])), ('bias', tensor([0.3236]))])\n",
            "epoch: 1390, test loss: 0.025532448664307594, loss: 0.010964717715978622\n",
            "OrderedDict([('weights', tensor([0.6456])), ('bias', tensor([0.3229]))])\n",
            "epoch: 1400, test loss: 0.0247737355530262, loss: 0.010621683672070503\n",
            "OrderedDict([('weights', tensor([0.6473])), ('bias', tensor([0.3221]))])\n",
            "epoch: 1410, test loss: 0.023946374654769897, loss: 0.0102781867608428\n",
            "OrderedDict([('weights', tensor([0.6490])), ('bias', tensor([0.3214]))])\n",
            "epoch: 1420, test loss: 0.023187648504972458, loss: 0.009934292174875736\n",
            "OrderedDict([('weights', tensor([0.6507])), ('bias', tensor([0.3207]))])\n",
            "epoch: 1430, test loss: 0.0223603006452322, loss: 0.009591430425643921\n",
            "OrderedDict([('weights', tensor([0.6525])), ('bias', tensor([0.3200]))])\n",
            "epoch: 1440, test loss: 0.021532922983169556, loss: 0.009247747249901295\n",
            "OrderedDict([('weights', tensor([0.6542])), ('bias', tensor([0.3193]))])\n",
            "epoch: 1450, test loss: 0.020774226635694504, loss: 0.00890403799712658\n",
            "OrderedDict([('weights', tensor([0.6559])), ('bias', tensor([0.3185]))])\n",
            "epoch: 1460, test loss: 0.019946854561567307, loss: 0.008561170659959316\n",
            "OrderedDict([('weights', tensor([0.6576])), ('bias', tensor([0.3178]))])\n",
            "epoch: 1470, test loss: 0.01911948248744011, loss: 0.00821731798350811\n",
            "OrderedDict([('weights', tensor([0.6593])), ('bias', tensor([0.3171]))])\n",
            "epoch: 1480, test loss: 0.018360769376158714, loss: 0.0078737773001194\n",
            "OrderedDict([('weights', tensor([0.6610])), ('bias', tensor([0.3164]))])\n",
            "epoch: 1490, test loss: 0.01753341034054756, loss: 0.007530786097049713\n",
            "OrderedDict([('weights', tensor([0.6627])), ('bias', tensor([0.3157]))])\n",
            "epoch: 1500, test loss: 0.01670604944229126, loss: 0.007186878472566605\n",
            "OrderedDict([('weights', tensor([0.6644])), ('bias', tensor([0.3150]))])\n",
            "epoch: 1510, test loss: 0.01594732329249382, loss: 0.006843519862741232\n",
            "OrderedDict([('weights', tensor([0.6661])), ('bias', tensor([0.3142]))])\n",
            "epoch: 1520, test loss: 0.015119964256882668, loss: 0.0065003493800759315\n",
            "OrderedDict([('weights', tensor([0.6678])), ('bias', tensor([0.3135]))])\n",
            "epoch: 1530, test loss: 0.014292603358626366, loss: 0.0061564454808831215\n",
            "OrderedDict([('weights', tensor([0.6695])), ('bias', tensor([0.3128]))])\n",
            "epoch: 1540, test loss: 0.013533895835280418, loss: 0.005813260562717915\n",
            "OrderedDict([('weights', tensor([0.6712])), ('bias', tensor([0.3121]))])\n",
            "epoch: 1550, test loss: 0.012706518173217773, loss: 0.005469911731779575\n",
            "OrderedDict([('weights', tensor([0.6730])), ('bias', tensor([0.3114]))])\n",
            "epoch: 1560, test loss: 0.011879158206284046, loss: 0.005126009229570627\n",
            "OrderedDict([('weights', tensor([0.6747])), ('bias', tensor([0.3107]))])\n",
            "epoch: 1570, test loss: 0.011086148209869862, loss: 0.004782738629728556\n",
            "OrderedDict([('weights', tensor([0.6764])), ('bias', tensor([0.3099]))])\n",
            "epoch: 1580, test loss: 0.010327416472136974, loss: 0.004439300857484341\n",
            "OrderedDict([('weights', tensor([0.6781])), ('bias', tensor([0.3092]))])\n",
            "epoch: 1590, test loss: 0.0095000509172678, loss: 0.004096209071576595\n",
            "OrderedDict([('weights', tensor([0.6798])), ('bias', tensor([0.3085]))])\n",
            "epoch: 1600, test loss: 0.008672690019011497, loss: 0.00375230610370636\n",
            "OrderedDict([('weights', tensor([0.6815])), ('bias', tensor([0.3078]))])\n",
            "epoch: 1610, test loss: 0.007913952693343163, loss: 0.003409049706533551\n",
            "OrderedDict([('weights', tensor([0.6832])), ('bias', tensor([0.3070]))])\n",
            "epoch: 1620, test loss: 0.007086604833602905, loss: 0.0030657723546028137\n",
            "OrderedDict([('weights', tensor([0.6849])), ('bias', tensor([0.3063]))])\n",
            "epoch: 1630, test loss: 0.006259244866669178, loss: 0.0027218698523938656\n",
            "OrderedDict([('weights', tensor([0.6866])), ('bias', tensor([0.3056]))])\n",
            "epoch: 1640, test loss: 0.005500525236129761, loss: 0.0023787878453731537\n",
            "OrderedDict([('weights', tensor([0.6883])), ('bias', tensor([0.3049]))])\n",
            "epoch: 1650, test loss: 0.004673170857131481, loss: 0.002035339130088687\n",
            "OrderedDict([('weights', tensor([0.6900])), ('bias', tensor([0.3042]))])\n",
            "epoch: 1660, test loss: 0.0038457990158349276, loss: 0.0016914367442950606\n",
            "OrderedDict([('weights', tensor([0.6918])), ('bias', tensor([0.3035]))])\n",
            "epoch: 1670, test loss: 0.0030870854388922453, loss: 0.0013485305244103074\n",
            "OrderedDict([('weights', tensor([0.6935])), ('bias', tensor([0.3027]))])\n",
            "epoch: 1680, test loss: 0.002259713364765048, loss: 0.0010049022966995835\n",
            "OrderedDict([('weights', tensor([0.6952])), ('bias', tensor([0.3020]))])\n",
            "epoch: 1690, test loss: 0.0014667033683508635, loss: 0.000661638390738517\n",
            "OrderedDict([('weights', tensor([0.6969])), ('bias', tensor([0.3013]))])\n",
            "epoch: 1700, test loss: 0.0006393313524313271, loss: 0.0003177322505507618\n",
            "OrderedDict([('weights', tensor([0.6986])), ('bias', tensor([0.3006]))])\n",
            "epoch: 1710, test loss: 0.0005780101055279374, loss: 0.0004444979131221771\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "epoch: 1720, test loss: 0.0005780101055279374, loss: 0.0004444979131221771\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "epoch: 1730, test loss: 0.0005780101055279374, loss: 0.0004444979131221771\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "epoch: 1740, test loss: 0.0005780101055279374, loss: 0.0004444979131221771\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "epoch: 1750, test loss: 0.0005780101055279374, loss: 0.0004444979131221771\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "epoch: 1760, test loss: 0.0005780101055279374, loss: 0.0004444979131221771\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "epoch: 1770, test loss: 0.0005780101055279374, loss: 0.0004444979131221771\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "epoch: 1780, test loss: 0.0005780101055279374, loss: 0.0004444979131221771\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "epoch: 1790, test loss: 0.0005780101055279374, loss: 0.0004444979131221771\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n"
          ]
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "epochs = 1800\n",
        "epoch_count = []\n",
        "train_loss_val = []\n",
        "test_loss_val = []\n",
        "\n",
        "\n",
        "for epoch in range(epochs):\n",
        "\n",
        "    model_0.train() #01 training the modelsetting model to training mode\n",
        "\n",
        "    y_pred = model_0(X_train) #02 forward pass\n",
        "\n",
        "    loss = loss_fn(y_pred, y_train) #03 calculate loss function\n",
        "    # print(f'loss: {loss}')\n",
        "\n",
        "    opti.zero_grad() #04 reset optimises\n",
        "\n",
        "    loss.backward() #05 perform back propogation\n",
        "\n",
        "    opti.step() #06 step the optimiser (performing gradient descent here)\n",
        "\n",
        "    \n",
        "\n",
        "    ###\n",
        "    model_0.eval() #setting to test mode\n",
        "    with torch.inference_mode():\n",
        "        test_pred = model_0(X_test)\n",
        "\n",
        "        test_loss = loss_fn(test_pred, y_test)\n",
        "\n",
        "    if epoch % 10 == 0:\n",
        "\n",
        "        epoch_count.append(epoch)\n",
        "        train_loss_val.append(loss.detach().numpy()) #to convert tesnors with autograd and other fancy things to numpy. also saves memory\n",
        "        test_loss_val.append(test_loss)\n",
        "        \n",
        "        print(f'epoch: {epoch}, test loss: {test_loss}, loss: {loss}')\n",
        "        print(model_0.state_dict())\n",
        "\n",
        "\n",
        "    \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "with torch.inference_mode():\n",
        "        y_pred = model_0(X_test)\n",
        "        plot_pred(predictions=y_pred) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "graphin loss curves"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x16ae92f50>"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(epoch_count, train_loss_val, label= 'Train loss')\n",
        "plt.plot(epoch_count, test_loss_val, label='Test Loss')\n",
        "plt.title('Train & Test loss curves')\n",
        "plt.ylabel('Loss')\n",
        "plt.xlabel('epochs')\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor(0.0007, grad_fn=<MeanBackward0>)"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "loss"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor(0.0007)"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "loss.detach()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array(0.0007076, dtype=float32)"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "loss.detach().numpy()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# saving model\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {},
      "outputs": [],
      "source": [
        "from pathlib import Path #P is caps lol missed it"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {},
      "outputs": [],
      "source": [
        "Model_path = Path(\"models\")\n",
        "Model_path.mkdir(parents = True, exist_ok=True) # creates dieectory\n",
        "\n",
        "model_name = \"01_first model.pth\" # .pt or .pth we use .pth here\n",
        "model_save_path = Model_path / model_name\n",
        "\n",
        "torch.save(model_0.state_dict(), model_save_path)\n",
        "\n",
        "#torch.save(obj=model_0.state_dict(),              # only saving the state_dict() only saves the models learned parameters\n",
        "#             f=MODEL_SAVE_PATH)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# loading model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "we have to create new instance of out model to load the saved model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "execution_count": 30,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "loadel_model = LinearRegressionModel()\n",
        "\n",
        "loadel_model.load_state_dict(torch.load(model_save_path))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "testing if loaded model matches the existing trained"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {},
      "outputs": [],
      "source": [
        "#first set it to eval mode\n",
        "loadel_model.eval()\n",
        "#then use contex manager to test\n",
        "\n",
        "with torch.inference_mode():\n",
        "    loaded_preds = loadel_model(X_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.8593],\n",
              "        [0.8733],\n",
              "        [0.8873],\n",
              "        [0.9013],\n",
              "        [0.9152],\n",
              "        [0.9292],\n",
              "        [0.9432],\n",
              "        [0.9572],\n",
              "        [0.9712],\n",
              "        [0.9852]])"
            ]
          },
          "execution_count": 32,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "loaded_preds"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.8593],\n",
              "        [0.8733],\n",
              "        [0.8873],\n",
              "        [0.9013],\n",
              "        [0.9152],\n",
              "        [0.9292],\n",
              "        [0.9432],\n",
              "        [0.9572],\n",
              "        [0.9712],\n",
              "        [0.9852]])"
            ]
          },
          "execution_count": 33,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y_pred"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True]])"
            ]
          },
          "execution_count": 34,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "loaded_preds == y_pred"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# device agnostic code"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'mps'"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "device = 'mps' if torch.backends.mps.is_available() else ('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "device # Mps = metal performance shaders on Apple M1 chip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.0000],\n",
              "        [0.0200],\n",
              "        [0.0400],\n",
              "        [0.0600],\n",
              "        [0.0800],\n",
              "        [0.1000],\n",
              "        [0.1200],\n",
              "        [0.1400],\n",
              "        [0.1600],\n",
              "        [0.1800],\n",
              "        [0.2000],\n",
              "        [0.2200],\n",
              "        [0.2400],\n",
              "        [0.2600],\n",
              "        [0.2800],\n",
              "        [0.3000],\n",
              "        [0.3200],\n",
              "        [0.3400],\n",
              "        [0.3600],\n",
              "        [0.3800],\n",
              "        [0.4000],\n",
              "        [0.4200],\n",
              "        [0.4400],\n",
              "        [0.4600],\n",
              "        [0.4800],\n",
              "        [0.5000],\n",
              "        [0.5200],\n",
              "        [0.5400],\n",
              "        [0.5600],\n",
              "        [0.5800],\n",
              "        [0.6000],\n",
              "        [0.6200],\n",
              "        [0.6400],\n",
              "        [0.6600],\n",
              "        [0.6800],\n",
              "        [0.7000],\n",
              "        [0.7200],\n",
              "        [0.7400],\n",
              "        [0.7600],\n",
              "        [0.7800],\n",
              "        [0.8000],\n",
              "        [0.8200],\n",
              "        [0.8400],\n",
              "        [0.8600],\n",
              "        [0.8800],\n",
              "        [0.9000],\n",
              "        [0.9200],\n",
              "        [0.9400],\n",
              "        [0.9600],\n",
              "        [0.9800]])"
            ]
          },
          "execution_count": 43,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "weight = 0.7\n",
        "bias = 0.3\n",
        "\n",
        "start = 0 \n",
        "end = 1 \n",
        "step = 0.02\n",
        "\n",
        "X = torch.arange(start, end, step).unsqueeze(1)\n",
        "\n",
        "X"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {},
      "outputs": [],
      "source": [
        "y = weight * X + bias"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "8.0"
            ]
          },
          "execution_count": 42,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "split_train = int(0.8 * len(X))\n",
        "\n",
        "X_train, y_train = X[:split_train], y[:split_train]\n",
        "X_test"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "in new notebook from here"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "authorship_tag": "ABX9TyPWSV7G5UGnYNRX5BGk3uPG",
      "include_colab_link": true,
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}