CoCalc -- Wine_Dataset_Code_Implementation.ipynb~1

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 / Wine_Dataset_Code_Implementation.ipynb~1
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/Wine_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",
      "metadata": {
        "id": "IsMaxq6AVXqf"
      },
      "source": [
        "This is a code that compares Kolmogorov Arnold Networks (KANs) with the Multi-Layer Pereptron (MLPs) using the wine dataset\n",
        "\n",
        "I aim to use graphical representation to understand how each model converges, the maximum accuracy achieved by each model, the loss each model has while training on the dataset.\n",
        "\n",
        "The comparison would also be done using some criterias such as precision,recall,f1 score and confusion matrix"
      ]
    },
    {
      "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": "292bab53-281e-4b7a-a15d-fca7e0fb5410"
      },
      "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-iop8nlv8\n",
            "  Running command git clone --filter=blob:none --quiet https://github.com/KindXiaoming/pykan.git /tmp/pip-req-build-iop8nlv8\n",
            "  Resolved https://github.com/KindXiaoming/pykan.git to commit f871c26d4df788ec1ba309c2c9c1803d82606b06\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Reading package lists... Done\n",
            "Building dependency tree... Done\n",
            "Reading state information... Done\n",
            "python3.10-venv is already the newest version (3.10.12-1~22.04.7).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 49 not upgraded.\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-3byfndk4\n",
            "  Running command git clone --filter=blob:none --quiet https://github.com/trevorstephens/gplearn.git /tmp/pip-req-build-3byfndk4\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"
          ]
        }
      ],
      "source": [
        "!pip install git+https://github.com/KindXiaoming/pykan.git\n",
        "!apt-get install python3.10-venv  # Install the Python 3.10 virtual environment package\n",
        "!python3.10 -m venv .venv310       # Create a virtual environment named .venv310 using Python 3.10\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",
        "torch.manual_seed(123)\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "viFNCJ0n_4Gw"
      },
      "source": [
        "##Models\n",
        "The models are being called with their default hyperparameter and layers\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-jPhfJ1l_1sT",
        "outputId": "8b197afb-2727-4ae0-e08b-563be349613e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "checkpoint directory created: ./model\n",
            "saving model version 0.0\n"
          ]
        }
      ],
      "source": [
        "# MLP Model\n",
        "mlp = MLPClassifier()\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,plotting the graph are written here."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gEgXBgcVMZhE"
      },
      "source": [
        "##Model Functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "id": "xt0grRxSyGU8"
      },
      "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, predicted.argmax(1))\n",
        "    test_loss = loss_fn(predicted, y_test)\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",
        "  kan_model_run = KAN_run(kan_model,x_train_tensor,y_train_long,x_test_tensor,y_test_long,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,5))\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='x')\n",
        "    plt.plot(epochs, kan_train_acc, label='KAN Train Accuracy',color='red',marker='x')\n",
        "    plt.plot(epochs, mlp_test_acc, label='MLP Test Accuracy',color='green',marker='x')\n",
        "    plt.plot(epochs, kan_test_acc, label='KAN Test Accuracy',color='yellow',marker='x')\n",
        "    plt.ylim(0.5, 1)\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('Accuracy')\n",
        "    plt.title('MLP and KAN 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='x')\n",
        "    plt.plot(epochs, kan_train_loss, label='KAN Train Loss',color='red',marker='x')\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",
        "  y_pred_mlp = mlp.predict(x_test_tensor)\n",
        "  y_pred_kan = kan(x_test_tensor).argmax(1)\n",
        "  mlp_classification= classification_report(y_test_tensor, y_pred_mlp)\n",
        "  kan_classification = classification_report(y_test_long, y_pred_kan)\n",
        "  mlp_confusion = confusion_matrix(y_test_tensor, y_pred_mlp)\n",
        "  kan_confusion = confusion_matrix(y_test_long, y_pred_kan)\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": 25,
      "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_kan0 = {'grid':[4,5,6],\n",
        "                    'k':[2,3,4],\n",
        "                    'noise_scale':[0.0001,0.01,0.1,0.001]}\n",
        "  clfkan = GridSearchCV(kan_tune, param_grid_kan0, 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_wine = 'https://gist.githubusercontent.com/tijptjik/9408623/raw/b237fa5848349a14a14e5d4107dc7897c21951f5/wine.csv'\n",
        "df = pd.read_csv(url_wine)\n",
        "df['Wine'] = df['Wine'].replace({1: 0, 2: 1, 3: 2})\n",
        "x = df.drop('Wine', axis=1).values\n",
        "y = df['Wine'].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, dtype=torch.float32)\n",
        "y_train_long = torch.tensor(y_train, dtype=torch.long)\n",
        "x_test_tensor = torch.tensor(X_test, dtype=torch.float32)\n",
        "y_test_tensor = torch.tensor(y_test, dtype=torch.float32)\n",
        "y_test_long = torch.tensor(y_test, dtype=torch.long)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6nF2UeWRHF6_"
      },
      "source": [
        "# Model Run\n",
        "Running the models over 100 epochs with different hidden layers for MLP and KAN with that of KAN being lower than MLP at all points\n",
        "\n",
        "Plotting the accuracies and loss over epochs\n",
        "\n",
        "Calculating other comparison criteria like the classification report and confusion matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {
        "id": "4cb1C0sFySfW"
      },
      "outputs": [],
      "source": [
        "epochs = 100"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WgRQmGitCypQ"
      },
      "source": [
        "## Model Run with 2 hidden layers of 27 and 10 neurons respectively\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kb8rWnAAqRH3",
        "outputId": "40bf9a37-9b59-4c05-a7bb-e0198eb7c51e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best parameters: {'activation': 'tanh', 'alpha': 0.001, 'hidden_layer_sizes': (27, 10), 'learning_rate': 'adaptive', 'learning_rate_init': 0.1, 'solver': 'adam'}\n"
          ]
        }
      ],
      "source": [
        "# mlp hyperparameter tunning for mlp0\n",
        "param_grid_mlp0 = {\n",
        "    'hidden_layer_sizes': [(27,10)],\n",
        "    'activation': ['relu', 'tanh'],\n",
        "    'alpha':[0.001,0.01],\n",
        "    'solver':['adam','sgd'],\n",
        "    'learning_rate_init':[0.1,0.00001],\n",
        "    'learning_rate':['adaptive','constant']}\n",
        "mlp_tune0 = MLPClassifier(max_iter=1000, random_state=123)\n",
        "clfmlp0 = GridSearchCV(mlp_tune0, param_grid_mlp0, cv=5, scoring='accuracy')\n",
        "clfmlp0.fit(x_train_tensor.numpy(), y_train_tensor.numpy())\n",
        "print(f\"Best parameters: {clfmlp0.best_params_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mhOCH9QGJYPh"
      },
      "outputs": [],
      "source": [
        "# Remove comment to run the code using ctrl + /\n",
        "kan_tune0 = KANWrapper(width=[13,27,10,3], seed=123)\n",
        "print(kan_hyperparameter(kan_tune0,x_train_tensor,y_train_tensor))\n",
        "# Result:  Best parameters: {'grid': 5, 'k': 2, 'noise_scale': 0.0001}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "FjZENRdneG24",
        "outputId": "4d5e8574-68bd-4e5d-bdf9-75f062094fdc"
      },
      "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.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [20/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [30/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [40/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [50/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [60/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [70/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [80/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [90/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [100/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [10/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [20/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [30/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [40/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [50/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [60/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [70/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [80/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [90/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [100/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "MLP Execution time: 0.69 seconds\n",
            "Epoch [10/100],KAN Train Loss: 0.0010, KAN Train Accuracy: 1.0000\n",
            "Epoch [20/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [30/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [40/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [50/100],KAN Train Loss: 0.0000, 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: 3.9198,KAN Test Accuracy: 0.9167\n",
            "Epoch [20/100],KAN Test Loss: 3.9198,KAN Test Accuracy: 0.9167\n",
            "Epoch [30/100],KAN Test Loss: 3.9198,KAN Test Accuracy: 0.9167\n",
            "Epoch [40/100],KAN Test Loss: 3.9198,KAN Test Accuracy: 0.9167\n",
            "Epoch [50/100],KAN Test Loss: 3.9198,KAN Test Accuracy: 0.9167\n",
            "Epoch [60/100],KAN Test Loss: 3.9198,KAN Test Accuracy: 0.9167\n",
            "Epoch [70/100],KAN Test Loss: 3.9198,KAN Test Accuracy: 0.9167\n",
            "Epoch [80/100],KAN Test Loss: 3.9198,KAN Test Accuracy: 0.9167\n",
            "Epoch [90/100],KAN Test Loss: 3.9198,KAN Test Accuracy: 0.9167\n",
            "Epoch [100/100],KAN Test Loss: 3.9198,KAN Test Accuracy: 0.9167\n",
            "KAN Execution time: 30.04 seconds\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 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       1.00      1.00      1.00        26\n",
            "         1.0       1.00      0.96      0.98        27\n",
            "         2.0       0.95      1.00      0.97        19\n",
            "\n",
            "    accuracy                           0.99        72\n",
            "   macro avg       0.98      0.99      0.99        72\n",
            "weighted avg       0.99      0.99      0.99        72\n",
            "\n",
            "MLP Confusion Matrix:\n",
            "[[26  0  0]\n",
            " [ 0 26  1]\n",
            " [ 0  0 19]]\n",
            "KAN Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.84      1.00      0.91        26\n",
            "           1       1.00      0.85      0.92        27\n",
            "           2       0.94      0.89      0.92        19\n",
            "\n",
            "    accuracy                           0.92        72\n",
            "   macro avg       0.93      0.92      0.92        72\n",
            "weighted avg       0.93      0.92      0.92        72\n",
            "\n",
            "KAN Confusion Matrix:\n",
            "[[26  0  0]\n",
            " [ 3 23  1]\n",
            " [ 2  0 17]]\n"
          ]
        }
      ],
      "source": [
        "# MLP Model\n",
        "mlp_0 = MLPClassifier(hidden_layer_sizes=(27,10),\n",
        "                    max_iter= 1000,\n",
        "                    activation='tanh',\n",
        "                    learning_rate_init= 0.1,\n",
        "                    learning_rate='adaptive',\n",
        "                    alpha= 0.001,\n",
        "                    solver='adam',\n",
        "                    random_state=123,\n",
        "                    verbose = False)\n",
        "\n",
        "# KAN Model\n",
        "kan_0 = KAN(width=[13,27,10,3], grid=5, k=2, noise_scale=0.0001,seed=123)\n",
        "mlp_metrics_0,kan_metrics_0 = run_models(mlp_0,kan_0,epochs)\n",
        "plot_comparison_over_epochs(mlp_metrics_0, kan_metrics_0,epochs)\n",
        "mlp_0.fit(x_train_tensor, y_train_tensor)\n",
        "criteria_comparison(mlp_0,kan_0,x_test_tensor,y_test_tensor)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YbpyCTy8yB21"
      },
      "source": [
        "## Model Run with 2 hidden layers of 40 and 15 neurons respectively"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "up71XoAz3s7c",
        "outputId": "9f04628c-d95c-4ebc-c131-a00bfe7d0380"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best parameters: {'activation': 'tanh', 'alpha': 0.1, 'hidden_layer_sizes': (40, 15), 'learning_rate': 'adaptive', 'learning_rate_init': 0.01, 'solver': 'adam'}\n"
          ]
        }
      ],
      "source": [
        "# mlp hyperparameter tunning for mlp1\n",
        "param_grid_mlp1 = {\n",
        "    'hidden_layer_sizes': [(40,15)],\n",
        "    'activation': ['relu', 'tanh'],\n",
        "    'alpha':[0.001,0.01,0.1,1],\n",
        "    'solver':['adam','sgd'],\n",
        "    'learning_rate_init':[0.01,0.0001],\n",
        "    'learning_rate':['adaptive','constant']}\n",
        "mlp_tune1 = MLPClassifier(max_iter=1000, random_state=123)\n",
        "clfmlp1 = GridSearchCV(mlp_tune1, param_grid_mlp1, cv=5, scoring='accuracy')\n",
        "clfmlp1.fit(x_train_tensor.numpy(), y_train_tensor.numpy())\n",
        "print(f\"Best parameters: {clfmlp1.best_params_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Dd4u2ScZaWo4"
      },
      "outputs": [],
      "source": [
        "# # Remove comment to run the code using ctrl + /\n",
        "# kan_tune1 = KANWrapper(width=[13,40,15,3], seed=123)\n",
        "# print(kan_hyperparameter(kan_tune1,x_train_tensor,y_train_tensor))\n",
        "# # Results:  Best parameters: {'grid': 6, 'k': 2, 'noise_scale': 0.0001}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "8rb3CLxS2Ij4",
        "outputId": "22b9e67e-495f-469f-f5a7-7d7a414c5607"
      },
      "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.0283, MLP Train Accuracy: 0.9717\n",
            "Epoch [20/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [30/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [40/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [50/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [60/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [70/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [80/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [90/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [100/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [10/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [20/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [30/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [40/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [50/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [60/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [70/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [80/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [90/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [100/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "MLP Execution time: 0.42 seconds\n",
            "Epoch [10/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [20/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [30/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [40/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [50/100],KAN Train Loss: 0.0000, 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: 1.1705,KAN Test Accuracy: 0.9722\n",
            "Epoch [20/100],KAN Test Loss: 1.1705,KAN Test Accuracy: 0.9722\n",
            "Epoch [30/100],KAN Test Loss: 1.1705,KAN Test Accuracy: 0.9722\n",
            "Epoch [40/100],KAN Test Loss: 1.1705,KAN Test Accuracy: 0.9722\n",
            "Epoch [50/100],KAN Test Loss: 1.1705,KAN Test Accuracy: 0.9722\n",
            "Epoch [60/100],KAN Test Loss: 1.1705,KAN Test Accuracy: 0.9722\n",
            "Epoch [70/100],KAN Test Loss: 1.1705,KAN Test Accuracy: 0.9722\n",
            "Epoch [80/100],KAN Test Loss: 1.1705,KAN Test Accuracy: 0.9722\n",
            "Epoch [90/100],KAN Test Loss: 1.1705,KAN Test Accuracy: 0.9722\n",
            "Epoch [100/100],KAN Test Loss: 1.1705,KAN Test Accuracy: 0.9722\n",
            "KAN Execution time: 53.67 seconds\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 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       0.96      1.00      0.98        26\n",
            "         1.0       1.00      0.96      0.98        27\n",
            "         2.0       1.00      1.00      1.00        19\n",
            "\n",
            "    accuracy                           0.99        72\n",
            "   macro avg       0.99      0.99      0.99        72\n",
            "weighted avg       0.99      0.99      0.99        72\n",
            "\n",
            "MLP Confusion Matrix:\n",
            "[[26  0  0]\n",
            " [ 1 26  0]\n",
            " [ 0  0 19]]\n",
            "KAN Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.93      1.00      0.96        26\n",
            "           1       1.00      0.96      0.98        27\n",
            "           2       1.00      0.95      0.97        19\n",
            "\n",
            "    accuracy                           0.97        72\n",
            "   macro avg       0.98      0.97      0.97        72\n",
            "weighted avg       0.97      0.97      0.97        72\n",
            "\n",
            "KAN Confusion Matrix:\n",
            "[[26  0  0]\n",
            " [ 1 26  0]\n",
            " [ 1  0 18]]\n"
          ]
        }
      ],
      "source": [
        "mlp_1 = MLPClassifier(hidden_layer_sizes=(40,15),\n",
        "                    max_iter=1000,\n",
        "                    activation='tanh',\n",
        "                    learning_rate_init= 0.01,\n",
        "                    learning_rate='adaptive',\n",
        "                    alpha= 0.1,\n",
        "                    solver='adam',\n",
        "                    random_state=123,\n",
        "                    verbose = False)\n",
        "\n",
        "\n",
        "kan_1= KAN(width=[13,40,15,3], grid=6, k=2, noise_scale=0.0001, seed=123)\n",
        "kan_1.update_grid_from_samples(x_train_tensor)\n",
        "num_epochs = 100\n",
        "mlp_metrics_1,kan_metrics_1 = run_models(mlp_1,kan_1,num_epochs)\n",
        "plot_comparison_over_epochs(mlp_metrics_1, kan_metrics_1,num_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": "N3yuk8W21J-u"
      },
      "source": [
        "## Model Run with 2 hidden layers of 15 and 7 neurons respectively"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OJk5Cm-n1stv",
        "outputId": "aca6c902-57f9-43d9-a585-696e472b050c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best parameters: {'activation': 'relu', 'alpha': 1, 'hidden_layer_sizes': (15, 7), 'learning_rate': 'adaptive', 'learning_rate_init': 0.1, 'solver': 'adam'}\n"
          ]
        }
      ],
      "source": [
        "# mlp hyperparameter tunning for mlp2\n",
        "param_grid_mlp2 = {\n",
        "    'hidden_layer_sizes': [(15,7)],\n",
        "    'activation': ['relu', 'tanh'],\n",
        "    'alpha':[0.001,0.01,0.1,1],\n",
        "    'solver':['adam','sgd'],\n",
        "    'learning_rate_init':[0.01,0.001,0.1],\n",
        "    'learning_rate':['adaptive','constant']}\n",
        "mlp_tune2 = MLPClassifier(max_iter=1000, random_state=123)\n",
        "clfmlp2 = GridSearchCV(mlp_tune2, param_grid_mlp2, cv=5, scoring='accuracy')\n",
        "clfmlp2.fit(x_train_tensor.numpy(), y_train_tensor.numpy())\n",
        "print(f\"Best parameters: {clfmlp2.best_params_}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sJy1xDM3t1tX"
      },
      "outputs": [],
      "source": [
        "# # Remove comment to run the code using ctrl + /\n",
        "# kan_tune2 = KANWrapper(width=[13,15,7,3], seed=123)\n",
        "# print(kan_hyperparameter(kan_tune2,x_train_tensor,y_train_tensor))\n",
        "# # Result:  Best parameters: {'grid': 6, 'k': 3, 'noise_scale': 0.1}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {
        "id": "sy6SpkkW1RaN",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "8c764c2c-d53e-44c1-b9ad-2bd84710d10d"
      },
      "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.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [20/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [30/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [40/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [50/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [60/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [70/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [80/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [90/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [100/100],MLP Train Loss: 0.0000, MLP Train Accuracy: 1.0000\n",
            "Epoch [10/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [20/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [30/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [40/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [50/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [60/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [70/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [80/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [90/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "Epoch [100/100],MLP Test Loss: 0.0139, MLP Test Accuracy: 0.9861\n",
            "MLP Execution time: 0.38 seconds\n",
            "Epoch [10/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [20/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [30/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [40/100],KAN Train Loss: 0.0000, KAN Train Accuracy: 1.0000\n",
            "Epoch [50/100],KAN Train Loss: 0.0000, 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.2545,KAN Test Accuracy: 0.9861\n",
            "Epoch [20/100],KAN Test Loss: 0.2545,KAN Test Accuracy: 0.9861\n",
            "Epoch [30/100],KAN Test Loss: 0.2545,KAN Test Accuracy: 0.9861\n",
            "Epoch [40/100],KAN Test Loss: 0.2545,KAN Test Accuracy: 0.9861\n",
            "Epoch [50/100],KAN Test Loss: 0.2545,KAN Test Accuracy: 0.9861\n",
            "Epoch [60/100],KAN Test Loss: 0.2545,KAN Test Accuracy: 0.9861\n",
            "Epoch [70/100],KAN Test Loss: 0.2545,KAN Test Accuracy: 0.9861\n",
            "Epoch [80/100],KAN Test Loss: 0.2545,KAN Test Accuracy: 0.9861\n",
            "Epoch [90/100],KAN Test Loss: 0.2545,KAN Test Accuracy: 0.9861\n",
            "Epoch [100/100],KAN Test Loss: 0.2545,KAN Test Accuracy: 0.9861\n",
            "KAN Execution time: 15.29 seconds\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 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       1.00      1.00      1.00        26\n",
            "         1.0       1.00      1.00      1.00        27\n",
            "         2.0       1.00      1.00      1.00        19\n",
            "\n",
            "    accuracy                           1.00        72\n",
            "   macro avg       1.00      1.00      1.00        72\n",
            "weighted avg       1.00      1.00      1.00        72\n",
            "\n",
            "MLP Confusion Matrix:\n",
            "[[26  0  0]\n",
            " [ 0 27  0]\n",
            " [ 0  0 19]]\n",
            "KAN Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.96      1.00      0.98        26\n",
            "           1       1.00      0.96      0.98        27\n",
            "           2       1.00      1.00      1.00        19\n",
            "\n",
            "    accuracy                           0.99        72\n",
            "   macro avg       0.99      0.99      0.99        72\n",
            "weighted avg       0.99      0.99      0.99        72\n",
            "\n",
            "KAN Confusion Matrix:\n",
            "[[26  0  0]\n",
            " [ 1 26  0]\n",
            " [ 0  0 19]]\n"
          ]
        }
      ],
      "source": [
        "mlp_2 = MLPClassifier(hidden_layer_sizes=(15,7),\n",
        "                    max_iter=1000,\n",
        "                    activation='relu',\n",
        "                    learning_rate_init= 0.1,\n",
        "                    learning_rate='adaptive',\n",
        "                    alpha= 1,\n",
        "                    solver='adam',\n",
        "                    random_state=42,\n",
        "                    verbose = False)\n",
        "\n",
        "\n",
        "kan_2= KAN(width=[13,15,7,3], grid=6, k=3, noise_scale=0.1, seed=123)\n",
        "kan_2.update_grid_from_samples(x_train_tensor)\n",
        "num_epochs = 100\n",
        "mlp_metrics_2,kan_metrics_2 = run_models(mlp_2,kan_2,num_epochs)\n",
        "plot_comparison_over_epochs(mlp_metrics_2, kan_metrics_2,num_epochs)\n",
        "mlp_2.fit(x_test_tensor, y_test_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",
        "WgRQmGitCypQ"
      ],
      "provenance": [],
      "authorship_tag": "ABX9TyPTC94244GratjCrT3VGaGD",
      "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.
