01_Putting_together_cpu.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": null,
      "metadata": {},
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "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": 1,
          "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": "markdown",
      "metadata": {},
      "source": [
        "# device agnostic code"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'cpu'"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "device # Mps = metal performance shaders on Apple M1 chip # this is cpu or cuda only"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "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": 3,
          "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": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "y = weight * X + bias"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
        "split_train = int(0.8 * len(X))\n",
        "\n",
        "X_train, y_train = X[:split_train], y[:split_train]\n",
        "X_test, y_test = X[split_train:], y[split_train:]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[0.0000],\n",
              "         [0.0200],\n",
              "         [0.0400],\n",
              "         [0.0600],\n",
              "         [0.0800]]),\n",
              " tensor([[0.3000],\n",
              "         [0.3140],\n",
              "         [0.3280],\n",
              "         [0.3420],\n",
              "         [0.3560]]))"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X_train[:5], y_train[:5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[0.8000],\n",
              "         [0.8200],\n",
              "         [0.8400],\n",
              "         [0.8600],\n",
              "         [0.8800]]),\n",
              " tensor([[0.8600],\n",
              "         [0.8740],\n",
              "         [0.8880],\n",
              "         [0.9020],\n",
              "         [0.9160]]))"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "X_test[:5], y_test[:5]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "plotting data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [],
      "source": [
        "def plot_it(X_train=X_train, y_train=y_train,\n",
        "            X_test=X_test, y_test=y_test,\n",
        "            y_pred=None):\n",
        "    plt.figure(figsize=(10,7))\n",
        "\n",
        "    plt.scatter(X_train, y_train, s=4, c='g', label='Train Data')\n",
        "\n",
        "    plt.scatter(X_test, y_test, s=10, c='y', label='Test Data')\n",
        "\n",
        "\n",
        "\n",
        "    if y_pred is not None:\n",
        "        plt.scatter(X_test, y_pred, s=2, c='r', label='Predictions')\n",
        "\n",
        "    plt.legend(prop={'size': 11})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_it()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "creating model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [],
      "source": [
        "class LinearRegression(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "\n",
        "        self.linearlayer = nn.Linear(in_features=1,\n",
        "                                     out_features=1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.linearlayer(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [],
      "source": [
        "torch.manual_seed = 42\n",
        "\n",
        "model = LinearRegression()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "LinearRegression(\n",
              "  (linearlayer): Linear(in_features=1, out_features=1, bias=True)\n",
              ")"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([[-0.1551]], requires_grad=True),\n",
              " Parameter containing:\n",
              " tensor([-0.0795], requires_grad=True)]"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "list(model.parameters())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "OrderedDict([('linearlayer.weight', tensor([[-0.1551]])),\n",
              "             ('linearlayer.bias', tensor([-0.0795]))])"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.state_dict()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "moving model to device (MPS on my local machine)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'cpu'"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "device"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "LinearRegression(\n",
              "  (linearlayer): Linear(in_features=1, out_features=1, bias=True)\n",
              ")"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model.to(device)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "device(type='cpu')"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "next(model.parameters()).device #model is a generator, only parameters has .device method"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {},
      "outputs": [],
      "source": [
        "X_train = X_train.to(device)\n",
        "y_train = y_train.to(device)\n",
        "X_test = X_test.to(device)\n",
        "y_test = y_test.to(device)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Choosing Loss function and optimizer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [],
      "source": [
        "loss_fn = nn.L1Loss()\n",
        "\n",
        "opt = torch.optim.SGD(params=model.parameters(), lr=0.01)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Create training Loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [],
      "source": [
        "epochs = 800"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "epoch: 0, loss: 0.713019609451294, test loss: 1.1270880699157715\n",
            "epoch: 100, loss: 0.1052737832069397, test loss: 0.26122692227363586\n",
            "epoch: 200, loss: 0.07034963369369507, test loss: 0.16344375908374786\n",
            "epoch: 300, loss: 0.036012765020132065, test loss: 0.08346586674451828\n",
            "epoch: 400, loss: 0.0017178781563416123, test loss: 0.004924160428345203\n",
            "epoch: 500, loss: 0.0044710286892950535, test loss: 0.010913628153502941\n",
            "epoch: 600, loss: 0.0044710286892950535, test loss: 0.010913628153502941\n",
            "epoch: 700, loss: 0.0044710286892950535, test loss: 0.010913628153502941\n"
          ]
        }
      ],
      "source": [
        "torch.manual_seed = 42\n",
        "\n",
        "epoch_num = [ ]\n",
        "train_loss_values = [ ]\n",
        "test_loss_values = [ ]\n",
        "\n",
        "\n",
        "for epoch in range(epochs):\n",
        "\n",
        "    # Training\n",
        "\n",
        "    model.train()\n",
        "\n",
        "    y_pred = model(X_train)\n",
        "\n",
        "    loss = loss_fn(y_pred, y_train)\n",
        "\n",
        "    opt.zero_grad()\n",
        "\n",
        "    loss.backward()\n",
        "\n",
        "    opt.step()\n",
        "\n",
        "    # Testing\n",
        "\n",
        "    model.eval()\n",
        "\n",
        "    with torch.inference_mode():\n",
        "\n",
        "        test_pred = model(X_test)\n",
        "        test_loss = loss_fn(test_pred, y_test)\n",
        "\n",
        "    if epoch%100 == 0:\n",
        "        epoch_num.append(epoch)\n",
        "        test_loss_values.append(test_loss.cpu().detach())\n",
        "        train_loss_values.append(loss.cpu().detach())\n",
        "\n",
        "        print(f'epoch: {epoch}, loss: {loss}, test loss: {test_loss}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "predicting using the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [],
      "source": [
        "with torch.inference_mode():\n",
        "        pred = model(X_test)       \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_it(y_pred = pred.cpu())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "plotting the loss curve"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Loss')"
            ]
          },
          "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_num, train_loss_values, label= 'Train')\n",
        "plt.plot(epoch_num, test_loss_values, label= 'test')\n",
        "plt.legend()\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# nice"
      ]
    }
  ],
  "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
}