02_pytorch_classification_exercises.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "02_pytorch_classification_exercises.ipynb",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/E1250/ZTM-Courses/blob/main/02_pytorch_classification_exercises.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 02. PyTorch Classification Exercises\n",
        "\n",
        "The following is a template for 02. PyTorch Classification exercises.\n",
        "\n",
        "It's only starter code and it's your job to fill in the blanks.\n",
        "\n",
        "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n",
        "\n",
        "Don't worry about trying to be *right* just try writing code that suffices the question.\n",
        "\n",
        "## Resources\n",
        "* These exercises are based on [notebook 02 of the learn PyTorch course](https://www.learnpytorch.io/02_pytorch_classification/).\n",
        "* You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)."
      ],
      "metadata": {
        "id": "ZKJFt7YxH8yl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import torch\n",
        "import torch\n",
        "\n",
        "# Setup device agnostic code\n",
        "device=\"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "\n",
        "# Setup random seed\n",
        "RANDOM_SEED = 42"
      ],
      "metadata": {
        "id": "CSrUPgapO0tf"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Make a binary classification dataset with Scikit-Learn's [`make_moons()`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) function.\n",
        "  * For consistency, the dataset should have 1000 samples and a `random_state=42`.\n",
        "  * Turn the data into PyTorch tensors. \n",
        "  * Split the data into training and test sets using `train_test_split` with 80% training and 20% testing."
      ],
      "metadata": {
        "id": "pH7jIZ2SPFee"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a dataset with Scikit-Learn's make_moons()\n",
        "from sklearn.datasets import make_moons\n",
        "\n",
        "X,y = make_moons(n_samples=1000,random_state=42,shuffle=True)"
      ],
      "metadata": {
        "id": "5t4VhPV1PX1X"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Turn data into a DataFrame\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "X_df = pd.DataFrame(data=X)\n",
        "y_df = pd.DataFrame(data=y)"
      ],
      "metadata": {
        "id": "SUeHZ3-3P9C7"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualize the data on a scatter plot\n",
        "import matplotlib.pyplot as plt\n",
        "plt.scatter(x=X[:,0],y=X[:,1],c=y,marker=',')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "owrkPSFvQPFI",
        "outputId": "44ef020d-b880-4100-8b6a-517c5c76263f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        }
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Turn data into tensors of dtype float\n",
        "X_t = torch.from_numpy(X).type(torch.float)\n",
        "y_t = torch.from_numpy(y).type(torch.float)\n",
        "\n",
        "# Split the data into train and test sets (80% train, 20% test)\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "X_train,X_test,y_train,y_test = train_test_split(X_t,y_t,train_size=0.8,shuffle=True,random_state=42)\n",
        "X_train,X_test = X_train.to(device),X_test.to(device)\n",
        "y_train,y_test = y_train.to(device),y_test.to(device)"
      ],
      "metadata": {
        "id": "bDhyHn9fR4dq"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Build a model by subclassing `nn.Module` that incorporates non-linear activation functions and is capable of fitting the data you created in 1.\n",
        "  * Feel free to use any combination of PyTorch layers (linear and non-linear) you want."
      ],
      "metadata": {
        "id": "cMIjxZdzQfPz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pyparsing.helpers import Sequence\n",
        "import torch\n",
        "from torch import nn\n",
        "\n",
        "# Inherit from nn.Module to make a model capable of fitting the mooon data\n",
        "class MoonModelV0(nn.Module):\n",
        "  def __init__(self,in_f,out_f,hidden):\n",
        "    super().__init__()\n",
        "    self.model = nn.Sequential(\n",
        "        nn.Linear(in_features=in_f,out_features=hidden,device=device),\n",
        "        nn.ReLU(),\n",
        "        nn.Linear(in_features=hidden,out_features=hidden,device=device),\n",
        "        nn.ReLU(),\n",
        "        nn.Linear(in_features=hidden,out_features=out_f,device=device)\n",
        "    )\n",
        "  def forward(self,x):\n",
        "    return self.model(x)\n",
        "\n",
        "# Instantiate the model\n",
        "model = MoonModelV0(2,1,5).to(device)"
      ],
      "metadata": {
        "id": "hwtyvm34Ri6Q"
      },
      "execution_count": 99,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Setup a binary classification compatible loss function and optimizer to use when training the model built in 2."
      ],
      "metadata": {
        "id": "DSj97RwyVeFE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup loss function\n",
        "loss_fn = nn.BCEWithLogitsLoss() # sigmoid layer built-in\n",
        "\n",
        "# Setup optimizer to optimize model's parameters\n",
        "optim = torch.optim.Adam(params = model.parameters(),lr = 0.1)"
      ],
      "metadata": {
        "id": "whSGw5qgVvxU"
      },
      "execution_count": 100,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. Create a training and testing loop to fit the model you created in 2 to the data you created in 1.\n",
        "  * Do a forward pass of the model to see what's coming out in the form of logits, prediction probabilities and labels.\n",
        "  * To measure model accuray, you can create your own accuracy function or use the accuracy function in [TorchMetrics](https://torchmetrics.readthedocs.io/en/latest/).\n",
        "  * Train the model for long enough for it to reach over 96% accuracy.\n",
        "  * The training loop should output progress every 10 epochs of the model's training and test set loss and accuracy."
      ],
      "metadata": {
        "id": "nvk4PfNTWUAt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# What's coming out of our model?\n",
        "\n",
        "# logits (raw outputs of model)\n",
        "logits = model(X_test)\n",
        "print(f\"Logits: {logits[:10]}\")\n",
        "\n",
        "# Prediction probabilities\n",
        "softmax = nn.Softmax(dim=1)\n",
        "probs = softmax(logits)\n",
        "print(f\"Pred probs: {probs[:10]}\")\n",
        "\n",
        "# Prediction labels\n",
        "preds = torch.argmax(probs,dim=1)\n",
        "print(f\"Pred labels: {preds[:10]}\")"
      ],
      "metadata": {
        "id": "AgnFdlamd2-D",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bcaf0b3e-c112-4785-d608-34969c840bd1"
      },
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Logits: tensor([[-0.4538],\n",
            "        [-0.5066],\n",
            "        [-0.4489],\n",
            "        [-0.5159],\n",
            "        [-0.4317],\n",
            "        [-0.4281],\n",
            "        [-0.4643],\n",
            "        [-0.4442],\n",
            "        [-0.4499],\n",
            "        [-0.5027]], grad_fn=<SliceBackward0>)\n",
            "Pred probs: tensor([[1.],\n",
            "        [1.],\n",
            "        [1.],\n",
            "        [1.],\n",
            "        [1.],\n",
            "        [1.],\n",
            "        [1.],\n",
            "        [1.],\n",
            "        [1.],\n",
            "        [1.]], grad_fn=<SliceBackward0>)\n",
            "Pred labels: tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's calculuate the accuracy using accuracy from TorchMetrics\n",
        "!pip -q install torchmetrics # Colab doesn't come with torchmetrics\n",
        "from torchmetrics import Accuracy\n",
        "\n",
        "## TODO: Uncomment this code to use the Accuracy function\n",
        "acc_fn = Accuracy(task=\"multiclass\", num_classes=2).to(device) # send accuracy function to device\n",
        "acc_fn"
      ],
      "metadata": {
        "id": "rUSDNHB4euoJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "218815d0-9372-415b-dd0a-6701403b307a"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MulticlassAccuracy()"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## TODO: Uncomment this to set the seed\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "\n",
        "# Setup epochs\n",
        "epochs = 1000\n",
        "\n",
        "# Send data to the device\n",
        "X_train,X_test = X_train.to(device),X_test.to(device)\n",
        "y_train,y_test = y_train.to(device),y_test.to(device)\n",
        "\n",
        "# Loop through the data\n",
        "for epoch in range(epochs):\n",
        "  ### Training\n",
        "  model.train()\n",
        "\n",
        "  # 1. Forward pass (logits output)\n",
        "  logits = model(X_train).squeeze()\n",
        "\n",
        "  # # Turn logits into prediction probabilities\n",
        "  # soft = nn.Sigmoid(dim=1)\n",
        "  # probs = soft(logits)\n",
        "\n",
        "  # # Turn prediction probabilities into prediction labels\n",
        "  # preds = torch.round(probs)\n",
        "\n",
        "  y_pred_probs = torch.sigmoid(logits)\n",
        "  y_pred = torch.round(y_pred_probs)\n",
        "\n",
        "  # 2. Calculaute the loss\n",
        "  loss = loss_fn(logits, y_train) # loss = compare model raw outputs to desired model outputs\n",
        "\n",
        "  # Calculate the accuracy\n",
        "  acc = acc_fn(y_pred, y_train) # the accuracy function needs to compare pred labels (not logits) with actual labels\n",
        "\n",
        "  # 3. Zero the gradients\n",
        "  optim.zero_grad()\n",
        "\n",
        "  # 4. Loss backward (perform backpropagation) - https://brilliant.org/wiki/backpropagation/#:~:text=Backpropagation%2C%20short%20for%20%22backward%20propagation,to%20the%20neural%20network's%20weights.\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. Step the optimizer (gradient descent) - https://towardsdatascience.com/gradient-descent-algorithm-a-deep-dive-cf04e8115f21#:~:text=Gradient%20descent%20(GD)%20is%20an,e.g.%20in%20a%20linear%20regression) \n",
        "  optim.step()\n",
        "\n",
        "  ### Testing\n",
        "  model.eval() \n",
        "  with torch.inference_mode():\n",
        "    # 1. Forward pass (to get the logits)\n",
        "    test_logits = model(X_test).squeeze()\n",
        "    \n",
        "    # Turn the test logits into prediction labels\n",
        "    # test_preds = torch.argmax(probs ,dim= 1)\n",
        "    test_preds = torch.round(torch.sigmoid(test_logits))\n",
        "    \n",
        "    # 2. Caculate the test loss/acc\n",
        "    test_loss = loss_fn(test_logits, y_test)\n",
        "    test_acc = acc_fn(test_preds, y_test.int())\n",
        "  \n",
        "\n",
        "  # Print out what's happening every 100 epochs\n",
        "  if epoch % 100 == 0:\n",
        "    print(f\"Epoch: {epoch} | Loss: {test_loss} | Accurecy: {test_acc}\")\n",
        "    "
      ],
      "metadata": {
        "id": "SHBY3h7XXnxt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb6771aa-5a81-43fd-f187-8f332aecbfb1"
      },
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 | Loss: 0.21298812329769135 | Accurecy: 0.8849999904632568\n",
            "Epoch: 100 | Loss: 0.21080049872398376 | Accurecy: 0.8849999904632568\n",
            "Epoch: 200 | Loss: 0.2251192331314087 | Accurecy: 0.8999999761581421\n",
            "Epoch: 300 | Loss: 0.21475620567798615 | Accurecy: 0.8849999904632568\n",
            "Epoch: 400 | Loss: 0.2106117457151413 | Accurecy: 0.8899999856948853\n",
            "Epoch: 500 | Loss: 0.21566805243492126 | Accurecy: 0.8849999904632568\n",
            "Epoch: 600 | Loss: 0.2116531878709793 | Accurecy: 0.8799999952316284\n",
            "Epoch: 700 | Loss: 0.2135179340839386 | Accurecy: 0.8849999904632568\n",
            "Epoch: 800 | Loss: 0.21051082015037537 | Accurecy: 0.8849999904632568\n",
            "Epoch: 900 | Loss: 0.21145057678222656 | Accurecy: 0.8799999952316284\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5. Make predictions with your trained model and plot them using the `plot_decision_boundary()` function created in this notebook."
      ],
      "metadata": {
        "id": "8Nwihtomj9JO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the model predictions\n",
        "import numpy as np\n",
        "\n",
        "def plot_decision_boundary(model, X, y):\n",
        "    # Put everything to CPU (works better with NumPy + Matplotlib)\n",
        "    model.to(\"cpu\")\n",
        "    X, y = X.to(\"cpu\"), y.to(\"cpu\")\n",
        "\n",
        "    # Source - https://madewithml.com/courses/foundations/neural-networks/ \n",
        "    # (with modifications)\n",
        "    x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1\n",
        "    y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1\n",
        "    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101), \n",
        "                         np.linspace(y_min, y_max, 101))\n",
        "\n",
        "    # Make features\n",
        "    X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()\n",
        "\n",
        "    # Make predictions\n",
        "    model.eval()\n",
        "    with torch.inference_mode():\n",
        "        y_logits = model(X_to_pred_on)\n",
        "\n",
        "    # Test for multi-class or binary and adjust logits to prediction labels\n",
        "    if len(torch.unique(y)) > 2:\n",
        "        y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1) # mutli-class\n",
        "    else: \n",
        "        y_pred = torch.round(torch.sigmoid(y_logits)) # binary\n",
        "    \n",
        "    # Reshape preds and plot\n",
        "    y_pred = y_pred.reshape(xx.shape).detach().numpy()\n",
        "    plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)\n",
        "    plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n",
        "    plt.xlim(xx.min(), xx.max())\n",
        "    plt.ylim(yy.min(), yy.max())"
      ],
      "metadata": {
        "id": "0YRzatb8a1P2"
      },
      "execution_count": 115,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot decision boundaries for training and test sets\n",
        "plot_decision_boundary(model,preds,y_test)\n"
      ],
      "metadata": {
        "id": "PMrcpyirig1d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 304
        },
        "outputId": "118ef38c-8437-4918-ec8f-f373d0fcb958"
      },
      "execution_count": 119,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-119-e7025d15a58e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Plot decision boundaries for training and test sets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mplot_decision_boundary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpreds\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-115-33a0031c6116>\u001b[0m in \u001b[0;36mplot_decision_boundary\u001b[0;34m(model, X, y)\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0;31m# Source - https://madewithml.com/courses/foundations/neural-networks/\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;31m# (with modifications)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m     \u001b[0mx_min\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_max\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     12\u001b[0m     \u001b[0my_min\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_max\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m     xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101), \n",
            "\u001b[0;31mIndexError\u001b[0m: too many indices for tensor of dimension 1"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6. Replicate the Tanh (hyperbolic tangent) activation function in pure PyTorch.\n",
        "  * Feel free to reference the [ML cheatsheet website](https://ml-cheatsheet.readthedocs.io/en/latest/activation_functions.html#tanh) for the formula."
      ],
      "metadata": {
        "id": "EtMYBvtciiAU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a straight line tensor\n",
        "line_tensor = torch.arange(-10,10,1)"
      ],
      "metadata": {
        "id": "BlXaWC5TkEUE"
      },
      "execution_count": 61,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Test torch.tanh() on the tensor and plot it\n",
        "value = torch.tanh(line_tensor)"
      ],
      "metadata": {
        "id": "vZPCcQmIkZjO"
      },
      "execution_count": 62,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Replicate torch.tanh() and plot it\n",
        "plt.plot(line_tensor,value)"
      ],
      "metadata": {
        "id": "J-ne__Kjkdc1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "outputId": "b148f6b2-5ffb-4834-da68-b628dc8d1133"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fe866f67040>]"
            ]
          },
          "metadata": {},
          "execution_count": 66
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 7. Create a multi-class dataset using the [spirals data creation function from CS231n](https://cs231n.github.io/neural-networks-case-study/) (see below for the code).\n",
        "  * Split the data into training and test sets (80% train, 20% test) as well as turn it into PyTorch tensors.\n",
        "  * Construct a model capable of fitting the data (you may need a combination of linear and non-linear layers).\n",
        "  * Build a loss function and optimizer capable of handling multi-class data (optional extension: use the Adam optimizer instead of SGD, you may have to experiment with different values of the learning rate to get it working).\n",
        "  * Make a training and testing loop for the multi-class data and train a model on it to reach over 95% testing accuracy (you can use any accuracy measuring function here that you like) - 1000 epochs should be plenty.\n",
        "  * Plot the decision boundaries on the spirals dataset from your model predictions, the `plot_decision_boundary()` function should work for this dataset too."
      ],
      "metadata": {
        "id": "Lbt1bNcWk5G9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Code for creating a spiral dataset from CS231n\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "RANDOM_SEED = 42\n",
        "np.random.seed(RANDOM_SEED)\n",
        "N = 100 # number of points per class\n",
        "D = 2 # dimensionality\n",
        "K = 3 # number of classes\n",
        "X = np.zeros((N*K,D)) # data matrix (each row = single example)\n",
        "y = np.zeros(N*K, dtype='uint8') # class labels\n",
        "for j in range(K):\n",
        "  ix = range(N*j,N*(j+1))\n",
        "  r = np.linspace(0.0,1,N) # radius\n",
        "  t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta\n",
        "  X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]\n",
        "  y[ix] = j\n",
        "# lets visualize the data\n",
        "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "tU-UNZsKlJls",
        "outputId": "f2707a7b-3195-472e-9210-4db8dcf39497"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Turn data into tensors\n",
        "import torch\n",
        "X = torch.from_numpy(X).type(torch.float) # features as float32\n",
        "y = torch.from_numpy(y).type(torch.LongTensor) # labels need to be of type long\n",
        "\n",
        "# Create train and test splits\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "X_train,X_test,y_train,y_test = train_test_split(X,y,shuffle=True ,random_state=42,train_size=0.8)\n"
      ],
      "metadata": {
        "id": "OWVrmkEyl0VP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's calculuate the accuracy for when we fit our model\n",
        "!pip -q install torchmetrics # colab doesn't come with torchmetrics\n",
        "from torchmetrics import Accuracy\n",
        "\n",
        "## TODO: uncomment the two lines below to send the accuracy function to the device\n",
        "acc_fn = Accuracy(task=\"multiclass\", num_classes=4).to(device)\n",
        "acc_fn"
      ],
      "metadata": {
        "id": "a-v-7f0op0tG",
        "outputId": "e3320317-430c-44dc-a05f-bda288dd8a6b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/518.6 KB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m276.5/518.6 KB\u001b[0m \u001b[31m8.2 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m518.6/518.6 KB\u001b[0m \u001b[31m8.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MulticlassAccuracy()"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Prepare device agnostic code\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "\n",
        "# Create model by subclassing nn.Module\n",
        "class ModelV1(nn.Module):\n",
        "  def __init__(self,in_f,out_f,hidden):\n",
        "    super().__init__()\n",
        "    self.model = nn.Sequential(\n",
        "        nn.Linear(in_features=in_f,out_features=hidden,device=device),\n",
        "        nn.ReLU(),\n",
        "        nn.Linear(in_features=hidden,out_features=hidden,device=device),\n",
        "        nn.ReLU(),\n",
        "        nn.Linear(in_features=hidden,out_features=out_f,device=device)\n",
        "    )\n",
        "  def forward(self,x):\n",
        "    return self.model(x)\n",
        "\n",
        "\n",
        "# Instantiate model and send it to device\n",
        "model = ModelV1(in_f = 2,out_f = 4,hidden=20).to(device)"
      ],
      "metadata": {
        "id": "DB3u3ldumapf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup data to be device agnostic\n",
        "X_train,X_test = X_train.to(device),X_test.to(device) \n",
        "y_train,y_test = y_train.to(device),y_test.to(device) \n",
        "\n",
        "# Print out first 10 untrained model outputs (forward pass)\n",
        "print(\"Logits:\")\n",
        "logits = model(X_train)\n",
        "print(logits[:10])\n",
        "\n",
        "print(\"Pred probs:\")\n",
        "probs = torch.softmax(logits,dim = 1)\n",
        "print(probs[:10])\n",
        "\n",
        "print(\"Pred labels:\")\n",
        "labels = torch.argmax(probs,dim = 1)\n",
        "print(labels[:10])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QE7XWSSunMTS",
        "outputId": "0b8b92ac-d01c-437d-cd3d-971f07fd2510"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Logits:\n",
            "tensor([[ 0.0146, -0.0208,  0.0492, -0.2500],\n",
            "        [ 0.0214, -0.0243,  0.0412, -0.2557],\n",
            "        [ 0.0121, -0.0457,  0.0711, -0.2529],\n",
            "        [ 0.0261, -0.0620,  0.1079, -0.2817],\n",
            "        [ 0.0350, -0.0797,  0.1326, -0.2917],\n",
            "        [ 0.0270, -0.0475,  0.0764, -0.2622],\n",
            "        [ 0.0203, -0.0496,  0.0771, -0.2585],\n",
            "        [-0.0334, -0.0528,  0.0866, -0.2365],\n",
            "        [ 0.0245, -0.0307,  0.0510, -0.2601],\n",
            "        [ 0.0258, -0.0629,  0.1095, -0.2823]], grad_fn=<SliceBackward0>)\n",
            "Pred probs:\n",
            "tensor([[0.2654, 0.2562, 0.2747, 0.2037],\n",
            "        [0.2679, 0.2559, 0.2732, 0.2030],\n",
            "        [0.2651, 0.2502, 0.2812, 0.2034],\n",
            "        [0.2677, 0.2451, 0.2905, 0.1967],\n",
            "        [0.2691, 0.2400, 0.2967, 0.1941],\n",
            "        [0.2683, 0.2490, 0.2818, 0.2009],\n",
            "        [0.2668, 0.2488, 0.2824, 0.2019],\n",
            "        [0.2548, 0.2499, 0.2873, 0.2080],\n",
            "        [0.2684, 0.2540, 0.2756, 0.2019],\n",
            "        [0.2676, 0.2449, 0.2909, 0.1966]], grad_fn=<SliceBackward0>)\n",
            "Pred labels:\n",
            "tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup loss function and optimizer\n",
        "loss_fn = nn.CrossEntropyLoss()\n",
        "optim = torch.optim.Adam(model.parameters(),lr = 0.1)"
      ],
      "metadata": {
        "id": "54EqLRKLo0AW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Build a training loop for the model\n",
        "epochs = 1000\n",
        "\n",
        "# Loop over data\n",
        "for epoch in range(epochs):\n",
        "  ## Training\n",
        "  model.train()\n",
        "  \n",
        "  # 1. Forward pass\n",
        "  logits = model(X_train)  \n",
        "  pred = torch.softmax(logits,dim = 1).argmax(dim = 1).type(torch.float)\n",
        "\n",
        "  # 2. Calculate the loss\n",
        "  loss = loss_fn(logits , y_train)\n",
        "  \n",
        "  # 3. Optimizer zero grad\n",
        "  optim.zero_grad()\n",
        "\n",
        "  # 4. Loss backward\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. Optimizer step\n",
        "  optim.step()\n",
        "\n",
        "  ## Testing\n",
        "  with torch.inference_mode():\n",
        "    model.eval()\n",
        "    # 1. Forward pass\n",
        "    pred_test = model(X_test)\n",
        "\n",
        "    # 2. Caculate loss and acc\n",
        "    loss_test = loss_fn(pred_test , y_test)\n",
        "\n",
        "  # Print out what's happening every 100 epochs\n",
        "  if epoch % 100 == 0:\n",
        "    print(f\"Epoch: {epoch}, Loss: {loss_test}, Accurecy: \")\n",
        "  "
      ],
      "metadata": {
        "id": "vIlExkUHnmxi",
        "outputId": "e3c6e43f-4cd5-41ec-adc1-e5bab39ba00b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0, Loss: 1.1166843175888062, Accurecy: \n",
            "Epoch: 100, Loss: 0.0010321191512048244, Accurecy: \n",
            "Epoch: 200, Loss: 6.611833669012412e-05, Accurecy: \n",
            "Epoch: 300, Loss: 2.374258474446833e-05, Accurecy: \n",
            "Epoch: 400, Loss: 1.7470303646405227e-05, Accurecy: \n",
            "Epoch: 500, Loss: 1.1359662494214717e-05, Accurecy: \n",
            "Epoch: 600, Loss: 2.664580097189173e-05, Accurecy: \n",
            "Epoch: 700, Loss: 2.9549171813414432e-05, Accurecy: \n",
            "Epoch: 800, Loss: 2.1779456801596098e-05, Accurecy: \n",
            "Epoch: 900, Loss: 2.7350957680027932e-05, Accurecy: \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot decision boundaries for training and test sets\n",
        "plt.figure(figsize = (12,7))\n",
        "plt.subplot(1,2,1)\n",
        "plt.title(\"Train\")\n",
        "plot_decision_boundary(model, X_train, y_train)\n",
        "plt.subplot(1,2,2)\n",
        "plt.title(\"Test\")\n",
        "plot_decision_boundary(model, X_test, y_test)"
      ],
      "metadata": {
        "id": "JrwVRbaE0keT",
        "outputId": "df61bac5-91fc-4d65-c662-ce7638d72380",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 444
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x504 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}