KAN_Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyPBN+LxkyYIb914nTegO5SB",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Anirudh-R-1201/CodePapers/blob/main/KAN_Classification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "DXaYhuQSi1ww"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class KolmogorovArnoldNetwork(nn.Module):\n",
        "    def __init__(self, input_dim=3072, output_dim=10, hidden_dim=128, num_inner_functions=16, num_outer_functions=10):\n",
        "        super(KolmogorovArnoldNetwork, self).__init__()\n",
        "\n",
        "        self.input_dim = input_dim\n",
        "        self.output_dim = output_dim\n",
        "        self.hidden_dim = hidden_dim\n",
        "        self.num_inner_functions = num_inner_functions\n",
        "        self.num_outer_functions = num_outer_functions\n",
        "\n",
        "        self.inner_functions = nn.ModuleList([\n",
        "            nn.Sequential(\n",
        "                nn.Linear(input_dim + 1, hidden_dim),\n",
        "                nn.ReLU(),\n",
        "                nn.Linear(hidden_dim, 1)\n",
        "            ) for _ in range(num_inner_functions)\n",
        "        ])\n",
        "\n",
        "        self.outer_functions = nn.Sequential(\n",
        "            nn.Linear(num_inner_functions, hidden_dim),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(hidden_dim, output_dim)\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        batch_size = x.size(0)\n",
        "        x = x.view(batch_size, -1)\n",
        "\n",
        "        inner_results = []\n",
        "        for j in range(self.num_inner_functions):\n",
        "            j_tensor = torch.full((batch_size, 1), j, dtype=torch.float, device=x.device)\n",
        "            input_j = torch.cat([x, j_tensor], dim=1)\n",
        "            inner_results.append(self.inner_functions[j](input_j))\n",
        "\n",
        "        inner_output = torch.cat(inner_results, dim=1)\n",
        "\n",
        "        output = self.outer_functions(inner_output)\n",
        "\n",
        "        return output\n"
      ],
      "metadata": {
        "id": "NRHPOLnHi8bq"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def load_cifar10(batch_size=8):#64):\n",
        "    transform = transforms.Compose([\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
        "    ])\n",
        "\n",
        "    trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)\n",
        "    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2, pin_memory=True)\n",
        "\n",
        "    testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)\n",
        "    testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2, pin_memory=True)\n",
        "\n",
        "    return trainloader, testloader"
      ],
      "metadata": {
        "id": "_D4_9ITUjAOl"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train(model, trainloader, epochs=25, lr=0.0001):\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
        "\n",
        "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "    model.to(device)\n",
        "\n",
        "    for epoch in range(epochs):\n",
        "        model.train()\n",
        "        running_loss = 0.0\n",
        "        for i, data in enumerate(trainloader, 0):\n",
        "            inputs, labels = data[0].to(device), data[1].to(device)\n",
        "\n",
        "            optimizer.zero_grad()\n",
        "            outputs = model(inputs)\n",
        "            loss = criterion(outputs, labels)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            running_loss += loss.item()\n",
        "            if i % 1000 == 199:\n",
        "              print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 200:.3f}')\n",
        "              running_loss = 0.0\n",
        "\n",
        "    #print('Finished Training')"
      ],
      "metadata": {
        "id": "zNvj2LTnjCP4"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def evaluate(model, testloader):\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "    model.to(device)\n",
        "\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for data in testloader:\n",
        "            images, labels = data[0].to(device), data[1].to(device)\n",
        "            outputs = model(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "\n",
        "    print(f'Accuracy on test images: {100 * correct / total:.2f}%')\n"
      ],
      "metadata": {
        "id": "sxpEW_1AjFdS"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(f\"Using device: {device}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ij7iCOBEjfj3",
        "outputId": "a66afc53-689b-4c80-8ff3-04031dd2d170"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device: cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "trainloader, testloader = load_cifar10()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZlI8fZSRjHKL",
        "outputId": "e114c16e-0685-4f9d-86ff-44a0780e6ca2"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model = KolmogorovArnoldNetwork().to(device)"
      ],
      "metadata": {
        "id": "7CnBOmlrjIdr"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train(model, trainloader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fv0pWzgcjL7o",
        "outputId": "90ffeb11-ade5-4517-afcf-566c0f885ed1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1,   200] loss: 2.088\n",
            "[1,  1200] loss: 9.038\n",
            "[1,  2200] loss: 8.553\n",
            "[1,  3200] loss: 8.134\n",
            "[1,  4200] loss: 8.076\n",
            "[1,  5200] loss: 7.811\n",
            "[1,  6200] loss: 7.736\n",
            "[2,   200] loss: 1.494\n",
            "[2,  1200] loss: 7.379\n",
            "[2,  2200] loss: 7.362\n",
            "[2,  3200] loss: 7.269\n",
            "[2,  4200] loss: 7.167\n",
            "[2,  5200] loss: 7.017\n",
            "[2,  6200] loss: 7.144\n",
            "[3,   200] loss: 1.349\n",
            "[3,  1200] loss: 6.711\n",
            "[3,  2200] loss: 6.775\n",
            "[3,  3200] loss: 6.638\n",
            "[3,  4200] loss: 6.732\n",
            "[3,  5200] loss: 6.672\n",
            "[3,  6200] loss: 6.527\n",
            "[4,   200] loss: 1.239\n",
            "[4,  1200] loss: 6.178\n",
            "[4,  2200] loss: 6.268\n",
            "[4,  3200] loss: 6.329\n",
            "[4,  4200] loss: 6.311\n",
            "[4,  5200] loss: 6.232\n",
            "[4,  6200] loss: 6.255\n",
            "[5,   200] loss: 1.156\n",
            "[5,  1200] loss: 5.783\n",
            "[5,  2200] loss: 5.936\n",
            "[5,  3200] loss: 5.952\n",
            "[5,  4200] loss: 6.052\n",
            "[5,  5200] loss: 5.848\n",
            "[5,  6200] loss: 5.911\n",
            "[6,   200] loss: 1.102\n",
            "[6,  1200] loss: 5.502\n",
            "[6,  2200] loss: 5.565\n",
            "[6,  3200] loss: 5.572\n",
            "[6,  4200] loss: 5.580\n",
            "[6,  5200] loss: 5.640\n",
            "[6,  6200] loss: 5.652\n",
            "[7,   200] loss: 1.003\n",
            "[7,  1200] loss: 5.148\n",
            "[7,  2200] loss: 5.208\n",
            "[7,  3200] loss: 5.336\n",
            "[7,  4200] loss: 5.384\n",
            "[7,  5200] loss: 5.371\n",
            "[7,  6200] loss: 5.287\n",
            "[8,   200] loss: 0.958\n",
            "[8,  1200] loss: 4.835\n",
            "[8,  2200] loss: 4.967\n",
            "[8,  3200] loss: 4.895\n",
            "[8,  4200] loss: 5.093\n",
            "[8,  5200] loss: 4.999\n",
            "[8,  6200] loss: 5.056\n",
            "[9,   200] loss: 0.915\n",
            "[9,  1200] loss: 4.524\n",
            "[9,  2200] loss: 4.499\n",
            "[9,  3200] loss: 4.761\n",
            "[9,  4200] loss: 4.707\n",
            "[9,  5200] loss: 4.796\n",
            "[9,  6200] loss: 4.728\n",
            "[10,   200] loss: 0.864\n",
            "[10,  1200] loss: 4.334\n",
            "[10,  2200] loss: 4.269\n",
            "[10,  3200] loss: 4.376\n",
            "[10,  4200] loss: 4.372\n",
            "[10,  5200] loss: 4.440\n",
            "[10,  6200] loss: 4.472\n",
            "[11,   200] loss: 0.763\n",
            "[11,  1200] loss: 3.896\n",
            "[11,  2200] loss: 3.985\n",
            "[11,  3200] loss: 4.134\n",
            "[11,  4200] loss: 4.075\n",
            "[11,  5200] loss: 4.292\n",
            "[11,  6200] loss: 4.275\n",
            "[12,   200] loss: 0.709\n",
            "[12,  1200] loss: 3.662\n",
            "[12,  2200] loss: 3.739\n",
            "[12,  3200] loss: 3.818\n",
            "[12,  4200] loss: 3.958\n",
            "[12,  5200] loss: 3.923\n",
            "[12,  6200] loss: 3.897\n",
            "[13,   200] loss: 0.666\n",
            "[13,  1200] loss: 3.404\n",
            "[13,  2200] loss: 3.479\n",
            "[13,  3200] loss: 3.488\n",
            "[13,  4200] loss: 3.651\n",
            "[13,  5200] loss: 3.578\n",
            "[13,  6200] loss: 3.557\n",
            "[14,   200] loss: 0.626\n",
            "[14,  1200] loss: 3.116\n",
            "[14,  2200] loss: 3.227\n",
            "[14,  3200] loss: 3.211\n",
            "[14,  4200] loss: 3.363\n",
            "[14,  5200] loss: 3.420\n",
            "[14,  6200] loss: 3.372\n",
            "[15,   200] loss: 0.542\n",
            "[15,  1200] loss: 2.828\n",
            "[15,  2200] loss: 2.980\n",
            "[15,  3200] loss: 3.082\n",
            "[15,  4200] loss: 3.014\n",
            "[15,  5200] loss: 3.042\n",
            "[15,  6200] loss: 3.173\n",
            "[16,   200] loss: 0.512\n",
            "[16,  1200] loss: 2.593\n",
            "[16,  2200] loss: 2.794\n",
            "[16,  3200] loss: 2.731\n",
            "[16,  4200] loss: 2.722\n",
            "[16,  5200] loss: 2.932\n",
            "[16,  6200] loss: 2.876\n",
            "[17,   200] loss: 0.456\n",
            "[17,  1200] loss: 2.403\n",
            "[17,  2200] loss: 2.450\n",
            "[17,  3200] loss: 2.615\n",
            "[17,  4200] loss: 2.570\n",
            "[17,  5200] loss: 2.680\n",
            "[17,  6200] loss: 2.628\n",
            "[18,   200] loss: 0.384\n",
            "[18,  1200] loss: 2.189\n",
            "[18,  2200] loss: 2.218\n",
            "[18,  3200] loss: 2.387\n",
            "[18,  4200] loss: 2.376\n",
            "[18,  5200] loss: 2.396\n",
            "[18,  6200] loss: 2.533\n",
            "[19,   200] loss: 0.426\n",
            "[19,  1200] loss: 1.953\n",
            "[19,  2200] loss: 2.006\n",
            "[19,  3200] loss: 2.174\n",
            "[19,  4200] loss: 2.159\n",
            "[19,  5200] loss: 2.298\n",
            "[19,  6200] loss: 2.205\n",
            "[20,   200] loss: 0.351\n",
            "[20,  1200] loss: 1.741\n",
            "[20,  2200] loss: 1.929\n",
            "[20,  3200] loss: 1.973\n",
            "[20,  4200] loss: 2.029\n",
            "[20,  5200] loss: 2.092\n",
            "[20,  6200] loss: 2.143\n",
            "[21,   200] loss: 0.323\n",
            "[21,  1200] loss: 1.596\n",
            "[21,  2200] loss: 1.719\n",
            "[21,  3200] loss: 1.921\n",
            "[21,  4200] loss: 1.863\n",
            "[21,  5200] loss: 1.772\n",
            "[21,  6200] loss: 1.885\n",
            "[22,   200] loss: 0.266\n",
            "[22,  1200] loss: 1.484\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "evaluate(model, testloader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nwjSC5SMjnT8",
        "outputId": "d3e7a336-5fba-4203-e16d-31650b130a19"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy on test images: 53.28%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_huXUNFGjonA"
      },
      "execution_count": 35,
      "outputs": []
    }
  ]
}