CoCalc -- Cancer_Dataset_Code_Implementation.ipynb~2

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place. Commercial Alternative to JupyterHub.

"Guiding Future STEM Leaders through Innovative Research Training" ~ thinkingbeyond.education
Path: ThinkingBeyond Activities / BeyondAI-2024-Mentee-Projects / emeka / Cancer_Dataset_Code_Implementation.ipynb~2
Views: ¹⁰⁷⁰
Image: ubuntu2204
{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ThinkingBeyond/BeyondAI-2024/blob/main/emeka/Cancer_Dataset_Code_Implementation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This code compares Multi-Layer Perceptron(MLP) with Kolmogorov Arnold Network (KAN) on the Wisconsin Breast Cancer Dataset.\n",
        "Each model is run with one hidden layer, tested over different width of the layer.\n",
        "The code test each model over a moderate width(27 neurons per layer), a larger width(64 neurons per layer) and a smaller width(18 neurons per layer)\n",
        "GridSearchCV was used by both models to calculate the best parameters and hyperparameters for the number of layer and neurons per layer chosen\n",
        "\n",
        "The result shows smooth covergence between each of the models,MLP had a very quick execution time and minumum loss unlike the KAN which took longer time to be executed and had a higher loss. Though, both models had similar accuracy score over the unseen data.\n"
      ],
      "metadata": {
        "id": "FZold8A3cMXE"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FRVmujAS_5KM"
      },
      "source": [
        "##Import Necessary Libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "BcXEEdI7_JeR",
        "outputId": "5448116e-7c9c-4f1e-8bf2-991fe96f31a5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting git+https://github.com/KindXiaoming/pykan.git\n",
            "  Cloning https://github.com/KindXiaoming/pykan.git to /tmp/pip-req-build-21vwrm42\n",
            "  Running command git clone --filter=blob:none --quiet https://github.com/KindXiaoming/pykan.git /tmp/pip-req-build-21vwrm42\n",
            "  Resolved https://github.com/KindXiaoming/pykan.git to commit f871c26d4df788ec1ba309c2c9c1803d82606b06\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Building wheels for collected packages: pykan\n",
            "  Building wheel for pykan (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for pykan: filename=pykan-0.2.8-py3-none-any.whl size=78208 sha256=2588868bf99eb288a347117698e7bd30e9aa1a54d3c4b0f7bbbeaf076602ce2e\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-ct7cab38/wheels/47/ca/5a/98124e020f3119f51c17f78738c621c140b7aa803b0feda76e\n",
            "Successfully built pykan\n",
            "Installing collected packages: pykan\n",
            "Successfully installed pykan-0.2.8\n",
            "Reading package lists... Done\n",
            "Building dependency tree... Done\n",
            "Reading state information... Done\n",
            "The following additional packages will be installed:\n",
            "  python3-pip-whl python3-setuptools-whl\n",
            "The following NEW packages will be installed:\n",
            "  python3-pip-whl python3-setuptools-whl python3.10-venv\n",
            "0 upgraded, 3 newly installed, 0 to remove and 49 not upgraded.\n",
            "Need to get 2,474 kB of archives.\n",
            "After this operation, 2,885 kB of additional disk space will be used.\n",
            "Get:1 http://archive.ubuntu.com/ubuntu jammy-updates/universe amd64 python3-pip-whl all 22.0.2+dfsg-1ubuntu0.5 [1,680 kB]\n",
            "Get:2 http://archive.ubuntu.com/ubuntu jammy-updates/universe amd64 python3-setuptools-whl all 59.6.0-1.2ubuntu0.22.04.2 [788 kB]\n",
            "Get:3 http://archive.ubuntu.com/ubuntu jammy-updates/universe amd64 python3.10-venv amd64 3.10.12-1~22.04.7 [5,718 B]\n",
            "Fetched 2,474 kB in 3s (949 kB/s)\n",
            "Selecting previously unselected package python3-pip-whl.\n",
            "(Reading database ... 123632 files and directories currently installed.)\n",
            "Preparing to unpack .../python3-pip-whl_22.0.2+dfsg-1ubuntu0.5_all.deb ...\n",
            "Unpacking python3-pip-whl (22.0.2+dfsg-1ubuntu0.5) ...\n",
            "Selecting previously unselected package python3-setuptools-whl.\n",
            "Preparing to unpack .../python3-setuptools-whl_59.6.0-1.2ubuntu0.22.04.2_all.deb ...\n",
            "Unpacking python3-setuptools-whl (59.6.0-1.2ubuntu0.22.04.2) ...\n",
            "Selecting previously unselected package python3.10-venv.\n",
            "Preparing to unpack .../python3.10-venv_3.10.12-1~22.04.7_amd64.deb ...\n",
            "Unpacking python3.10-venv (3.10.12-1~22.04.7) ...\n",
            "Setting up python3-setuptools-whl (59.6.0-1.2ubuntu0.22.04.2) ...\n",
            "Setting up python3-pip-whl (22.0.2+dfsg-1ubuntu0.5) ...\n",
            "Setting up python3.10-venv (3.10.12-1~22.04.7) ...\n",
            "Python 3.10.12\n",
            "Requirement already satisfied: scikit-learn==1.6.0 in /usr/local/lib/python3.10/dist-packages (1.6.0)\n",
            "Requirement already satisfied: pandas==2.2.2 in /usr/local/lib/python3.10/dist-packages (2.2.2)\n",
            "Requirement already satisfied: matplotlib==3.8.0 in /usr/local/lib/python3.10/dist-packages (3.8.0)\n",
            "Requirement already satisfied: torch==2.5.1+cu121 in /usr/local/lib/python3.10/dist-packages (2.5.1+cu121)\n",
            "Requirement already satisfied: numpy==1.26.4 in /usr/local/lib/python3.10/dist-packages (1.26.4)\n",
            "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn==1.6.0) (1.13.1)\n",
            "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn==1.6.0) (1.4.2)\n",
            "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn==1.6.0) (3.5.0)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas==2.2.2) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas==2.2.2) (2024.2)\n",
            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas==2.2.2) (2024.2)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib==3.8.0) (1.3.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib==3.8.0) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib==3.8.0) (4.55.3)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib==3.8.0) (1.4.7)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib==3.8.0) (24.2)\n",
            "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib==3.8.0) (11.0.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib==3.8.0) (3.2.0)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch==2.5.1+cu121) (3.16.1)\n",
            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch==2.5.1+cu121) (4.12.2)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch==2.5.1+cu121) (3.4.2)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch==2.5.1+cu121) (3.1.4)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch==2.5.1+cu121) (2024.10.0)\n",
            "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.10/dist-packages (from torch==2.5.1+cu121) (1.13.1)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy==1.13.1->torch==2.5.1+cu121) (1.3.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas==2.2.2) (1.17.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch==2.5.1+cu121) (3.0.2)\n",
            "Collecting git+https://github.com/trevorstephens/gplearn.git\n",
            "  Cloning https://github.com/trevorstephens/gplearn.git to /tmp/pip-req-build-9czscjjq\n",
            "  Running command git clone --filter=blob:none --quiet https://github.com/trevorstephens/gplearn.git /tmp/pip-req-build-9czscjjq\n",
            "  Resolved https://github.com/trevorstephens/gplearn.git to commit 64517a85fd6d6c50f9ee9e5599f97458da278951\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: scikit-learn>=1.0.2 in /usr/local/lib/python3.10/dist-packages (from gplearn==0.5.dev0) (1.6.0)\n",
            "Requirement already satisfied: joblib>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from gplearn==0.5.dev0) (1.4.2)\n",
            "Requirement already satisfied: numpy>=1.19.5 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.0.2->gplearn==0.5.dev0) (1.26.4)\n",
            "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.0.2->gplearn==0.5.dev0) (1.13.1)\n",
            "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.0.2->gplearn==0.5.dev0) (3.5.0)\n",
            "Building wheels for collected packages: gplearn\n",
            "  Building wheel for gplearn (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for gplearn: filename=gplearn-0.5.dev0-py3-none-any.whl size=25731 sha256=ff7d8ca7361da0321b091ba86987be9c4edf2b1d81694d2b9c963c7105fceef6\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-bul6l3ka/wheels/80/ca/31/ed49dcfa9cebd48e1fc4e025a428c8898845195c5774669b3b\n",
            "Successfully built gplearn\n",
            "Installing collected packages: gplearn\n",
            "Successfully installed gplearn-0.5.dev0\n"
          ]
        }
      ],
      "source": [
        "!pip install git+https://github.com/KindXiaoming/pykan.git\n",
        "!apt-get install python3.10-venv\n",
        "!python3.10 -m venv .venv310\n",
        "!source .venv310/bin/activate\n",
        "!python --version  # 3.10.12\n",
        "!pip install scikit-learn==1.6.0 pandas==2.2.2 matplotlib==3.8.0 torch==2.5.1+cu121 numpy==1.26.4\n",
        "!pip install git+https://github.com/trevorstephens/gplearn.git"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "OtDshUPVgoba"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from kan import *\n",
        "from sklearn.neural_network import MLPClassifier\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.metrics import accuracy_score, confusion_matrix, recall_score, classification_report\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from gplearn.genetic import SymbolicRegressor, SymbolicTransformer\n",
        "from sklearn.utils.estimator_checks import check_estimator\n",
        "import time\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "viFNCJ0n_4Gw"
      },
      "source": [
        "##Models\n",
        "The models are being called here along with the default number of layers and hyperparameter"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HpSNDbUSXR56",
        "outputId": "ad3ff95c-4b3a-4402-9e0c-177bdcf55cab"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "checkpoint directory created: ./model\n",
            "saving model version 0.0\n"
          ]
        }
      ],
      "source": [
        "#MLP Model\n",
        "mlp = MLPClassifier()#default parameters\n",
        "#KAN Model\n",
        "kan = KAN(width=[2,2,1])# should be adjusted based on dataset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RXqFvEH1BNB1"
      },
      "source": [
        "#Functions\n",
        "All the functions to be used for calculating the accuracies, losses, precision, recall, confusion matrix. The function to plot the graph is also written here."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gEgXBgcVMZhE"
      },
      "source": [
        "##Model Functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "L7ex_yBiBW3P"
      },
      "outputs": [],
      "source": [
        "def MLP_run(mlp,X_train,y_train,X_test,y_test,epochs):\n",
        "  y_train = torch.tensor(y_train, dtype=torch.float32)\n",
        "  y_test = torch.tensor(y_test, dtype=torch.float32)\n",
        "  train_accuracies,test_accuracies = [],[]\n",
        "  train_losses,test_losses = [],[]\n",
        "  criterion = nn.MSELoss()\n",
        "  start_time = time.time()\n",
        "\n",
        "  for epoch in range(epochs):\n",
        "    mlp.partial_fit(X_train, y_train, classes=np.unique(y_train))\n",
        "    y_pred_train = mlp.predict(X_train)\n",
        "    train_acc = accuracy_score(y_train, torch.tensor(y_pred_train))\n",
        "    train_loss = criterion(torch.tensor(y_pred_train, dtype=torch.float32), torch.tensor(y_train, dtype=torch.float32))\n",
        "    train_accuracies.append(train_acc)\n",
        "    train_losses.append(train_loss.item())\n",
        "    if (epoch + 1) % 10 == 0:\n",
        "      print(f'Epoch [{epoch+1}/{epochs}],MLP Train Loss: {train_loss.item():.4f}, MLP Train Accuracy: {train_acc:.4f}')\n",
        "\n",
        "  for epoch in range(epochs):\n",
        "    y_pred_test = mlp.predict(X_test)\n",
        "    test_acc = accuracy_score(torch.tensor(y_test), torch.tensor(y_pred_test))\n",
        "    test_loss = criterion(torch.tensor(y_pred_test, dtype=torch.float32), torch.tensor(y_test, dtype=torch.float32))\n",
        "    test_accuracies.append(test_acc)\n",
        "    test_losses.append(test_loss.item())\n",
        "    if (epoch + 1) % 10 == 0:\n",
        "      print(f'Epoch [{epoch+1}/{epochs}],MLP Test Loss: {test_loss.item():.4f}, MLP Test Accuracy: {test_acc:.4f}')\n",
        "  end_time = time.time()\n",
        "  MLP_Execution_Time = end_time - start_time\n",
        "  return train_accuracies,test_accuracies,train_losses,test_losses,MLP_Execution_Time\n",
        "\n",
        "\n",
        "def KAN_run(model,X_train,y_train,X_test,y_test,epochs):\n",
        "  y_train = torch.tensor(y_train, dtype=torch.long)\n",
        "  y_test = torch.tensor(y_test, dtype=torch.long)\n",
        "  optimizer = torch.optim.Adam(model.parameters(), lr=0.1)\n",
        "  loss_fn = nn.CrossEntropyLoss()\n",
        "  kan_train_accuracy = []\n",
        "  kan_test_accuracy = []\n",
        "  kan_train_loss = []\n",
        "  kan_test_loss = []\n",
        "  starting_time = time.time()\n",
        "\n",
        "  for epoch in range(epochs): #training\n",
        "    optimizer.zero_grad()\n",
        "    outputs = model(X_train)\n",
        "    predicted = torch.argmax(outputs, dim=1)\n",
        "    train_accuracy = accuracy_score(y_train, predicted)\n",
        "    train_loss = loss_fn(outputs, y_train)\n",
        "    train_loss.backward()\n",
        "    optimizer.step()\n",
        "    kan_train_accuracy.append(train_accuracy)\n",
        "    kan_train_loss.append(train_loss.item())\n",
        "    if (epoch + 1) % 10 == 0:\n",
        "      print(f'Epoch [{epoch+1}/{epochs}],KAN Train Loss: {train_loss.item():.4f}, KAN Train Accuracy: {train_accuracy:.4f}')\n",
        "\n",
        "  for epoch in range(epochs): # testing\n",
        "    predicted = model(x_test_tensor)\n",
        "    test_accuracy = accuracy_score(y_test_tensor, predicted.argmax(1))\n",
        "    test_loss = loss_fn(predicted, y_test_tensor)\n",
        "    kan_test_accuracy.append(test_accuracy)\n",
        "    kan_test_loss.append(test_loss.item())\n",
        "    if (epoch + 1) % 10 == 0:\n",
        "      print(f'Epoch [{epoch+1}/{epochs}],KAN Test Loss: {test_loss.item():.4f},KAN Test Accuracy: {test_accuracy:.4f}')\n",
        "  final_time = time.time()\n",
        "  KAN_Execution_Time = final_time - starting_time\n",
        "  return kan_train_accuracy, kan_test_accuracy, kan_train_loss, kan_test_loss, KAN_Execution_Time"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QuDnSAvzc2lt"
      },
      "source": [
        "##Model Run Function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "lxvrmcWvC1Ue"
      },
      "outputs": [],
      "source": [
        "def run_models(mlp_model,kan_model,epochs):\n",
        "  mlp_model_run = MLP_run(mlp_model,x_train_tensor,y_train_tensor,x_test_tensor,y_test_tensor,epochs)\n",
        "  mlp_metrics = [mlp_model_run[0],mlp_model_run[1],mlp_model_run[2],mlp_model_run[3]]\n",
        "  print(f'MLP Execution time: {mlp_model_run[4]:.2f} seconds')\n",
        "\n",
        "  print()\n",
        "\n",
        "  kan_model_run = KAN_run(kan_model,x_train_tensor,y_train_tensor,x_test_tensor,y_test_tensor,epochs)\n",
        "  kan_metrics = [kan_model_run[0],kan_model_run[1],kan_model_run[2],kan_model_run[3]]\n",
        "  print(f'KAN Execution time: {kan_model_run[4]:.2f} seconds')\n",
        "  return mlp_metrics,kan_metrics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hI3eyPDc1gbD"
      },
      "source": [
        "##Plot Function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "LUsqvwwO1eq7"
      },
      "outputs": [],
      "source": [
        "def plot_comparison_over_epochs(mlp_metrics,kan_metrics, num_epochs):\n",
        "    epochs = range(1, num_epochs + 1)\n",
        "    mlp_train_acc, mlp_test_acc, mlp_train_loss, mlp_test_loss = mlp_metrics\n",
        "    kan_train_acc, kan_test_acc, kan_train_loss, kan_test_loss = kan_metrics\n",
        "    plt.figure(figsize=(10,6))\n",
        "\n",
        "    # Graph of Train Accuracy for both models over number of epochs\n",
        "    plt.subplot(121)\n",
        "    plt.plot(epochs, mlp_train_acc, label='MLP Train Accuracy',color='blue',marker='*')\n",
        "    plt.plot(epochs, kan_train_acc, label='KAN Train Accuracy',color='red',marker='*')\n",
        "    plt.plot(epochs, mlp_test_acc, label='MLP Test Accuracy',color='green',marker='*')\n",
        "    plt.plot(epochs, kan_test_acc, label='KAN Test Accuracy',color='yellow',marker='*')\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('Accuracy')\n",
        "    plt.title('MLP and KAN Train and Test Accuracy Over Epochs')\n",
        "    plt.legend()\n",
        "\n",
        "    # Graph of loss of both models during training\n",
        "    plt.subplot(122)\n",
        "    plt.plot(epochs, mlp_train_loss, label='MLP Train Loss',color='blue',marker='*')\n",
        "    plt.plot(epochs, kan_train_loss, label='KAN Train Loss',color='red',marker='*')\n",
        "    plt.ylim(0, 1)\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('Loss')\n",
        "    plt.title('Training Loss Over Epochs')\n",
        "    plt.legend()\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TMS-nQNQaqwE"
      },
      "source": [
        "##Comparison Criteria Functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "O5i0dI9bavhf"
      },
      "outputs": [],
      "source": [
        "def criteria_comparison(mlp,kan,x_test_tensor,y_test_tensor):\n",
        "  mlp_classification= classification_report(y_test_tensor, mlp.predict(x_test_tensor))\n",
        "  kan_classification = classification_report(y_test_tensor, kan(x_test_tensor).argmax(1))\n",
        "  mlp_confusion = confusion_matrix(y_test_tensor, mlp.predict(x_test_tensor))\n",
        "  kan_confusion = confusion_matrix(y_test_tensor, kan(x_test_tensor).argmax(1))\n",
        "  print(f'MLP Classification Report:\\n{mlp_classification}')\n",
        "  print(f'MLP Confusion Matrix:\\n{mlp_confusion}')\n",
        "  print(f'KAN Classification Report:\\n{kan_classification}')\n",
        "  print(f'KAN Confusion Matrix:\\n{kan_confusion}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yNbcf_WhsvNQ"
      },
      "source": [
        "##KAN Hyperparameter Tunning Function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "RAybot1JQsZQ"
      },
      "outputs": [],
      "source": [
        "class KANWrapper:\n",
        "    def __init__(self, width, grid=3, k=2, noise_scale=0.1, mult_arity=2, seed=123):\n",
        "        self.width = width\n",
        "        self.grid = grid\n",
        "        self.k = k\n",
        "        self.noise_scale = noise_scale\n",
        "        self.mult_arity = mult_arity\n",
        "        self.seed = seed\n",
        "        self.model = KAN(width=width, grid=grid, k=k, noise_scale=noise_scale, mult_arity=mult_arity, seed=seed)\n",
        "    def fit(self, X, y):\n",
        "        self.model.update_grid_from_samples(torch.tensor(X, dtype=torch.float32))  # Assuming X is a NumPy array\n",
        "        return self\n",
        "    def predict(self, X):\n",
        "        X_tensor = torch.tensor(X, dtype=torch.float32)  # Assuming X is a NumPy array\n",
        "        outputs = self.model(X_tensor)\n",
        "        return outputs.argmax(1).numpy()\n",
        "    def get_params(self, deep=True):\n",
        "        return {\"width\": self.width,\n",
        "                \"grid\": self.grid,\n",
        "                \"k\": self.k,\n",
        "                \"noise_scale\": self.noise_scale,\n",
        "                \"mult_arity\": self.mult_arity,\n",
        "                \"seed\": self.seed\n",
        "               }\n",
        "    def set_params(self, **parameters):\n",
        "        for parameter, value in parameters.items():\n",
        "            setattr(self, parameter, value)\n",
        "        self.model = KAN(width=self.width, grid=self.grid, k=self.k, noise_scale=self.noise_scale, mult_arity=self.mult_arity, seed=self.seed)\n",
        "        return self\n",
        "\n",
        "def kan_hyperparameter(kan_tune,x_train_tensor,y_train_tensor):\n",
        "  param_grid_kan = {'grid':[4,5,6],\n",
        "                      'k':[2,3,4],\n",
        "                      'noise_scale':[0.1,0.01,0.001,0.2]}\n",
        "  clfkan = GridSearchCV(kan_tune, param_grid_kan, cv=5, scoring='accuracy')\n",
        "  clfkan.fit(x_train_tensor.numpy(), y_train_tensor.numpy())\n",
        "  return f\"Best parameters: {clfkan.best_params_}\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3wE_1Z3gMOp7"
      },
      "source": [
        "#Dataset\n",
        "The dataset to be used for the analysis is loaded here as well as preparation for the dataset using standard scaler(to make every feature have a mean of 0 and a standard deviation of 1) for faster convergence and imporved performance"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cDe6EHenCQT0"
      },
      "source": [
        "##Load Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "VLD4BDBHCTRr"
      },
      "outputs": [],
      "source": [
        "url_wisconsin_breast_cancer = 'https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data'\n",
        "df = pd.read_csv(url_wisconsin_breast_cancer, header=None)\n",
        "df[10]=df[10].replace(2,0)\n",
        "df[10]=df[10].replace(4,1)\n",
        "x = df.drop([6, 10], axis=1).values\n",
        "y = df[10].values"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qSsKZk7TCafa"
      },
      "source": [
        "##Prepare Dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "bHLgU-5yCZLj"
      },
      "outputs": [],
      "source": [
        "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.4, random_state=42)\n",
        "# Standardize features\n",
        "scaler = StandardScaler()\n",
        "X_train = scaler.fit_transform(x_train)\n",
        "X_test = scaler.transform(x_test)\n",
        "# Converting data to tensors\n",
        "x_train_tensor = torch.tensor(X_train, dtype=torch.float32)\n",
        "y_train_tensor = torch.tensor(y_train)\n",
        "x_test_tensor = torch.tensor(X_test, dtype=torch.float32)\n",
        "y_test_tensor = torch.tensor(y_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WgRQmGitCypQ"
      },
      "source": [
        "# Runing the model\n",
        "Running the models over 100 epochs with different neurons per layer for MLP and KAN\n",
        "\n",
        "Plotting the accuracies and loss over epochs\n",
        "\n",
        "Calculating other comparison criteria\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "QHDiSpNY8RB4"
      },
      "outputs": [],
      "source": [
        "epochs = 100"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hWPr9ED5WqPq"
      },
      "source": [
        "### Model Run with 1 hidden layer of 27 neurons"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-6EPziiK5kMf",
        "outputId": "284dcc2b-5cce-4bcf-ed6d-3503f44c5041"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best parameters: {'activation': 'relu', 'alpha': 0.01, 'hidden_layer_sizes': 27, 'learning_rate': 'adaptive', 'learning_rate_init': 0.001, 'solver': 'adam'}\n"
          ]
        }
      ],
      "source": [
        "# Hyperparmeter Tunning for the hidden layer\n",
        "param_grid_mlp_0 = {'hidden_layer_sizes': [(27)],\n",
        "    'activation': ['relu', 'tanh','logistics'],\n",
        "    'alpha':[0.01,0.1],\n",
        "    'learning_rate_init':[0.001,0.01,0.1,1],\n",
        "    'solver':['adam','sgd'],\n",
        "    'learning_rate':['adaptive','constant']}\n",
        "mlp_0 = MLPClassifier(max_iter=1000, random_state=123)\n",
        "clfmlp_0 = GridSearchCV(mlp_0, param_grid_mlp_0, cv=5, scoring='accuracy')\n",
        "clfmlp_0.fit(x_train_tensor.numpy(), y_train_tensor.numpy())\n",
        "print(f\"Best parameters: {clfmlp_0.best_params_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "eBomuvIg5SOE"
      },
      "outputs": [],
      "source": [
        "# # Remove comment to run the code using ctrl + /\n",
        "# kan_tune_0 = KANWrapper(width=[9,27,2], seed=123)\n",
        "# print(kan_hyperparameter( kan_tune_0,x_train_tensor,y_train_tensor))\n",
        "# # Result:  Best parameters: {'grid': 5, 'k': 2, 'noise_scale': 0.001}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "CCNVHkA8lKgp",
        "outputId": "ab34ec91-b406-42bc-a0bf-60a382ee36ee",
        "collapsed": true
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "checkpoint directory created: ./model\n",
            "saving model version 0.0\n",
            "Epoch [10/100],MLP Train Loss: 0.0477, MLP Train Accuracy: 0.9523\n",
            "Epoch [20/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [30/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [40/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [50/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [60/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [70/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [80/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [90/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [100/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [10/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [20/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [30/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [40/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [50/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [60/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [70/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [80/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [90/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [100/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "MLP Execution time: 1.68 seconds\n",
            "\n",
            "Epoch [10/100],KAN Train Loss: 0.0919, KAN Train Accuracy: 0.9666\n",
            "Epoch [20/100],KAN Train Loss: 0.0125, KAN Train Accuracy: 0.9976\n",
            "Epoch [30/100],KAN Train Loss: 0.0038, KAN Train Accuracy: 0.9976\n",
            "Epoch [40/100],KAN Train Loss: 0.0025, KAN Train Accuracy: 1.0000\n",
            "Epoch [50/100],KAN Train Loss: 0.0028, KAN Train Accuracy: 0.9976\n",
            "Epoch [60/100],KAN Train Loss: 0.0018, KAN Train Accuracy: 1.0000\n",
            "Epoch [70/100],KAN Train Loss: 0.0007, KAN Train Accuracy: 1.0000\n",
            "Epoch [80/100],KAN Train Loss: 0.0002, KAN Train Accuracy: 1.0000\n",
            "Epoch [90/100],KAN Train Loss: 0.0001, KAN Train Accuracy: 1.0000\n",
            "Epoch [100/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [10/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "Epoch [20/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "Epoch [30/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "Epoch [40/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "Epoch [50/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "Epoch [60/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "Epoch [70/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "Epoch [80/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "Epoch [90/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "Epoch [100/100],KAN Test Loss: 0.4149,KAN Test Accuracy: 0.9464\n",
            "KAN Execution time: 24.70 seconds\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MLP Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.98      0.97      0.98       185\n",
            "           1       0.95      0.97      0.96        95\n",
            "\n",
            "    accuracy                           0.97       280\n",
            "   macro avg       0.97      0.97      0.97       280\n",
            "weighted avg       0.97      0.97      0.97       280\n",
            "\n",
            "MLP Confusion Matrix:\n",
            "[[180   5]\n",
            " [  3  92]]\n",
            "KAN Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.95      0.97      0.96       185\n",
            "           1       0.94      0.89      0.92        95\n",
            "\n",
            "    accuracy                           0.95       280\n",
            "   macro avg       0.95      0.93      0.94       280\n",
            "weighted avg       0.95      0.95      0.95       280\n",
            "\n",
            "KAN Confusion Matrix:\n",
            "[[180   5]\n",
            " [ 10  85]]\n"
          ]
        }
      ],
      "source": [
        "mlp_2 = MLPClassifier(hidden_layer_sizes=(27),\n",
        "                    max_iter=1000,\n",
        "                    activation='relu',\n",
        "                    learning_rate='adaptive',\n",
        "                    learning_rate_init=0.001,\n",
        "                    alpha= 0.01,\n",
        "                    solver='adam',\n",
        "                    random_state=123,\n",
        "                    verbose = False)\n",
        "kan_2= KAN(width=[9,27,2],\n",
        "           grid=5,\n",
        "           k=2,\n",
        "           noise_scale=0.001,\n",
        "           seed=123)\n",
        "\n",
        "mlp_metrics_2,kan_metrics_2 = run_models(mlp_2,kan_2,epochs)\n",
        "plot_comparison_over_epochs(mlp_metrics_2, kan_metrics_2,epochs)\n",
        "mlp_2.fit(x_train_tensor, y_train_tensor)\n",
        "criteria_comparison(mlp_2,kan_2,x_test_tensor,y_test_tensor)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kWipDkJG2CPT"
      },
      "source": [
        "### Model Run with 1 hidden layer1 of 64 neurons"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DClPPVtr7WWh",
        "outputId": "a68ed202-3050-41ba-9248-ad2abb63a9d5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best parameters: {'activation': 'relu', 'alpha': 0.01, 'hidden_layer_sizes': 64, 'learning_rate': 'adaptive', 'learning_rate_init': 0.001, 'solver': 'sgd'}\n"
          ]
        }
      ],
      "source": [
        "# Hyperparameter Tunning for the hidden layer\n",
        "param_grid_mlp_1 = {'hidden_layer_sizes': [(64)],\n",
        "    'activation': ['relu', 'tanh','logistics'],\n",
        "    'alpha':[0.01,0.1],\n",
        "    'learning_rate_init':[0.001,0.01,0.1,1],\n",
        "    'solver':['adam','sgd'],\n",
        "    'learning_rate':['adaptive','constant']}\n",
        "mlp_1 = MLPClassifier(max_iter=1000, random_state=123)\n",
        "clfmlp_1 = GridSearchCV(mlp_1, param_grid_mlp_1, cv=5, scoring='accuracy')\n",
        "clfmlp_1.fit(x_train_tensor.numpy(), y_train_tensor.numpy())\n",
        "print(f\"Best parameters: {clfmlp_1.best_params_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "bfnuLwAp4xVU"
      },
      "outputs": [],
      "source": [
        "# # Remove comment to run the code using ctrl + /\n",
        "# kan_tune_1 = KANWrapper(width=[9,64,2], seed=123)\n",
        "# print(kan_hyperparameter(kan_tune_1,x_train_tensor,y_train_tensor))\n",
        "# # Result: Best parameters: {'grid': 6, 'k': 2, 'noise_scale': 0.001}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "8rb3CLxS2Ij4",
        "outputId": "e38149d7-4875-456b-e81f-7186dfdbf846"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "checkpoint directory created: ./model\n",
            "saving model version 0.0\n",
            "Epoch [10/100],MLP Train Loss: 0.4678, MLP Train Accuracy: 0.5322\n",
            "Epoch [20/100],MLP Train Loss: 0.0788, MLP Train Accuracy: 0.9212\n",
            "Epoch [30/100],MLP Train Loss: 0.0477, MLP Train Accuracy: 0.9523\n",
            "Epoch [40/100],MLP Train Loss: 0.0453, MLP Train Accuracy: 0.9547\n",
            "Epoch [50/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [60/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [70/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [80/100],MLP Train Loss: 0.0477, MLP Train Accuracy: 0.9523\n",
            "Epoch [90/100],MLP Train Loss: 0.0453, MLP Train Accuracy: 0.9547\n",
            "Epoch [100/100],MLP Train Loss: 0.0453, MLP Train Accuracy: 0.9547\n",
            "Epoch [10/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [20/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [30/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [40/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [50/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [60/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [70/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [80/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [90/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "Epoch [100/100],MLP Test Loss: 0.0286, MLP Test Accuracy: 0.9714\n",
            "MLP Execution time: 1.07 seconds\n",
            "\n",
            "Epoch [10/100],KAN Train Loss: 0.0533, KAN Train Accuracy: 0.9928\n",
            "Epoch [20/100],KAN Train Loss: 0.0061, KAN Train Accuracy: 0.9976\n",
            "Epoch [30/100],KAN Train Loss: 0.0031, KAN Train Accuracy: 0.9976\n",
            "Epoch [40/100],KAN Train Loss: 0.0016, KAN Train Accuracy: 1.0000\n",
            "Epoch [50/100],KAN Train Loss: 0.0002, KAN Train Accuracy: 1.0000\n",
            "Epoch [60/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [70/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [80/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [90/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [100/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [10/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "Epoch [20/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "Epoch [30/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "Epoch [40/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "Epoch [50/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "Epoch [60/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "Epoch [70/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "Epoch [80/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "Epoch [90/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "Epoch [100/100],KAN Test Loss: 0.3729,KAN Test Accuracy: 0.9571\n",
            "KAN Execution time: 57.68 seconds\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MLP Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.98      0.97      0.98       185\n",
            "           1       0.95      0.96      0.95        95\n",
            "\n",
            "    accuracy                           0.97       280\n",
            "   macro avg       0.96      0.97      0.96       280\n",
            "weighted avg       0.97      0.97      0.97       280\n",
            "\n",
            "MLP Confusion Matrix:\n",
            "[[180   5]\n",
            " [  4  91]]\n",
            "KAN Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.97      0.97      0.97       185\n",
            "           1       0.94      0.94      0.94        95\n",
            "\n",
            "    accuracy                           0.96       280\n",
            "   macro avg       0.95      0.95      0.95       280\n",
            "weighted avg       0.96      0.96      0.96       280\n",
            "\n",
            "KAN Confusion Matrix:\n",
            "[[179   6]\n",
            " [  6  89]]\n"
          ]
        }
      ],
      "source": [
        "mlp_1 = MLPClassifier(hidden_layer_sizes=(64),\n",
        "                    max_iter=1000,\n",
        "                    activation='relu',\n",
        "                    learning_rate_init=0.001,\n",
        "                    learning_rate='adaptive',\n",
        "                    alpha= 0.01,\n",
        "                    solver='sgd',\n",
        "                    random_state=123,\n",
        "                    verbose = False)\n",
        "kan_1= KAN(width=[9,64,2],\n",
        "           grid=6,\n",
        "           k=2,\n",
        "           noise_scale=0.001,\n",
        "           seed=123)\n",
        "\n",
        "mlp_metrics_1,kan_metrics_1 = run_models(mlp_1,kan_1,epochs)\n",
        "plot_comparison_over_epochs(mlp_metrics_1, kan_metrics_1,epochs)\n",
        "mlp_1.fit(x_train_tensor, y_train_tensor)\n",
        "criteria_comparison(mlp_1,kan_1,x_test_tensor,y_test_tensor)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ogd9G4eXRTXg"
      },
      "source": [
        "### Model Run with 1 hidden layer of 18 neuron"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CPe6TU-c9_wu",
        "outputId": "1da9007c-be44-4af5-f680-b4c58e6a259e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best parameters: {'activation': 'relu', 'alpha': 0.01, 'hidden_layer_sizes': 18, 'learning_rate': 'adaptive', 'learning_rate_init': 0.001, 'solver': 'sgd'}\n"
          ]
        }
      ],
      "source": [
        "# Hyperparameter Tunning for the hidden layer\n",
        "param_grid_mlp_2 = {'hidden_layer_sizes': [(18)],\n",
        "    'activation': ['relu', 'tanh','logistics'],\n",
        "    'alpha':[0.01,0.1],\n",
        "    'learning_rate_init':[0.001,0.01,0.1,1],\n",
        "    'solver':['adam','sgd'],\n",
        "    'learning_rate':['adaptive','constant']}\n",
        "mlp_2 = MLPClassifier(max_iter=1000, random_state=123)\n",
        "clfmlp_2 = GridSearchCV(mlp_2, param_grid_mlp_2, cv=5, scoring='accuracy')\n",
        "clfmlp_2.fit(x_train_tensor.numpy(), y_train_tensor.numpy())\n",
        "print(f\"Best parameters: {clfmlp_2.best_params_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "tL_-GPeT6GMp"
      },
      "outputs": [],
      "source": [
        "# # Remove comment to run the code using ctrl + /\n",
        "# kan_tune_2 = KANWrapper(width=[9,18,2], seed=123)\n",
        "# print(kan_hyperparameter(kan_tune_2,x_train_tensor,y_train_tensor))\n",
        "# # Result:  Best parameters: {'grid': 5, 'k': 2, 'noise_scale': 0.01}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "M7PNrcYfRYjx",
        "outputId": "4b1aed6d-e1a9-4a91-f05d-441d27d60271"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "checkpoint directory created: ./model\n",
            "saving model version 0.0\n",
            "Epoch [10/100],MLP Train Loss: 0.1002, MLP Train Accuracy: 0.8998\n",
            "Epoch [20/100],MLP Train Loss: 0.0621, MLP Train Accuracy: 0.9379\n",
            "Epoch [30/100],MLP Train Loss: 0.0453, MLP Train Accuracy: 0.9547\n",
            "Epoch [40/100],MLP Train Loss: 0.0477, MLP Train Accuracy: 0.9523\n",
            "Epoch [50/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [60/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [70/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [80/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [90/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [100/100],MLP Train Loss: 0.0430, MLP Train Accuracy: 0.9570\n",
            "Epoch [10/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "Epoch [20/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "Epoch [30/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "Epoch [40/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "Epoch [50/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "Epoch [60/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "Epoch [70/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "Epoch [80/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "Epoch [90/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "Epoch [100/100],MLP Test Loss: 0.0357, MLP Test Accuracy: 0.9643\n",
            "MLP Execution time: 1.69 seconds\n",
            "\n",
            "Epoch [10/100],KAN Train Loss: 0.0842, KAN Train Accuracy: 0.9737\n",
            "Epoch [20/100],KAN Train Loss: 0.0191, KAN Train Accuracy: 0.9952\n",
            "Epoch [30/100],KAN Train Loss: 0.0051, KAN Train Accuracy: 0.9976\n",
            "Epoch [40/100],KAN Train Loss: 0.0064, KAN Train Accuracy: 0.9976\n",
            "Epoch [50/100],KAN Train Loss: 0.0030, KAN Train Accuracy: 0.9976\n",
            "Epoch [60/100],KAN Train Loss: 0.0021, KAN Train Accuracy: 1.0000\n",
            "Epoch [70/100],KAN Train Loss: 0.0020, KAN Train Accuracy: 0.9976\n",
            "Epoch [80/100],KAN Train Loss: 0.0007, KAN Train Accuracy: 1.0000\n",
            "Epoch [90/100],KAN Train Loss: 0.0003, KAN Train Accuracy: 1.0000\n",
            "Epoch [100/100],KAN Train Loss: 0.0002, KAN Train Accuracy: 1.0000\n",
            "Epoch [10/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "Epoch [20/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "Epoch [30/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "Epoch [40/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "Epoch [50/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "Epoch [60/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "Epoch [70/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "Epoch [80/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "Epoch [90/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "Epoch [100/100],KAN Test Loss: 0.2966,KAN Test Accuracy: 0.9571\n",
            "KAN Execution time: 18.61 seconds\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MLP Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.98      0.97      0.98       185\n",
            "           1       0.95      0.96      0.95        95\n",
            "\n",
            "    accuracy                           0.97       280\n",
            "   macro avg       0.96      0.97      0.96       280\n",
            "weighted avg       0.97      0.97      0.97       280\n",
            "\n",
            "MLP Confusion Matrix:\n",
            "[[180   5]\n",
            " [  4  91]]\n",
            "KAN Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.97      0.97      0.97       185\n",
            "           1       0.94      0.94      0.94        95\n",
            "\n",
            "    accuracy                           0.96       280\n",
            "   macro avg       0.95      0.95      0.95       280\n",
            "weighted avg       0.96      0.96      0.96       280\n",
            "\n",
            "KAN Confusion Matrix:\n",
            "[[179   6]\n",
            " [  6  89]]\n"
          ]
        }
      ],
      "source": [
        "mlp_2 = MLPClassifier(hidden_layer_sizes=(18),\n",
        "                    max_iter=1000,\n",
        "                    activation='relu',\n",
        "                    learning_rate='adaptive',\n",
        "                    learning_rate_init=0.001,\n",
        "                    alpha= 0.01,\n",
        "                    solver='sgd',\n",
        "                    random_state=123,\n",
        "                    verbose = False)\n",
        "kan_2= KAN(width=[9,18,2],\n",
        "           grid=5,\n",
        "           k=2,\n",
        "           noise_scale=0.01,\n",
        "           seed=123)\n",
        "\n",
        "mlp_metrics_2,kan_metrics_2 = run_models(mlp_2,kan_2,epochs)\n",
        "plot_comparison_over_epochs(mlp_metrics_2, kan_metrics_2,epochs)\n",
        "mlp_2.fit(x_train_tensor, y_train_tensor)\n",
        "criteria_comparison(mlp_2,kan_2,x_test_tensor,y_test_tensor)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "FRVmujAS_5KM",
        "viFNCJ0n_4Gw",
        "RXqFvEH1BNB1",
        "gEgXBgcVMZhE",
        "QuDnSAvzc2lt",
        "hI3eyPDc1gbD",
        "TMS-nQNQaqwE",
        "yNbcf_WhsvNQ",
        "3wE_1Z3gMOp7",
        "cDe6EHenCQT0",
        "qSsKZk7TCafa"
      ],
      "provenance": [],
      "authorship_tag": "ABX9TyNAM1z3A3rzAL7kT81nAKf5",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place. Commercial Alternative to JupyterHub.

Product

Resources

Company

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more, all in one place. Commercial Alternative to JupyterHub.

Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place. Commercial Alternative to JupyterHub.
