05-kan-nueral-dekoniser-simple-rnn.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"1Ndsu_Qkj7z4oW403GUi8FTqfQHBbz5zy","timestamp":1715105172745},{"file_id":"1ldgGaSTeewcb9jMPlkxfqibKUajGiEUo","timestamp":1715104899225},{"file_id":"11Sef4F0MBYfB1t45tSvI8Sp2tt-xEMkH","timestamp":1715096133162},{"file_id":"1s-o5axy2u3eFh6apgCS5U--gN3NzHFu8","timestamp":1715075632633}],"gpuType":"T4","authorship_tag":"ABX9TyPCYxE6M5yPIAYDl1HSbaq7"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"},"accelerator":"GPU"},"cells":[{"cell_type":"code","execution_count":1,"metadata":{"id":"zaPaHzVAPWMS","executionInfo":{"status":"ok","timestamp":1715120593057,"user_tz":-330,"elapsed":4094,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}}},"outputs":[],"source":["import math\n","from torch import nn, Tensor\n","import torch\n","import matplotlib.pyplot as plt"]},{"cell_type":"code","source":["# https://github.com/Blealtan/efficient-kan/blob/master/src/efficient_kan/kan.py\n","\n","import torch\n","import torch.nn.functional as F\n","import math\n","\n","\n","class KANLinear(torch.nn.Module):\n","    def __init__(\n","        self,\n","        in_features,\n","        out_features,\n","        grid_size=5,\n","        spline_order=3,\n","        scale_noise=0.1,\n","        scale_base=1.0,\n","        scale_spline=1.0,\n","        enable_standalone_scale_spline=True,\n","        base_activation=torch.nn.SiLU,\n","        grid_eps=0.02,\n","        grid_range=[-1, 1],\n","    ):\n","        super(KANLinear, self).__init__()\n","        self.in_features = in_features\n","        self.out_features = out_features\n","        self.grid_size = grid_size\n","        self.spline_order = spline_order\n","\n","        h = (grid_range[1] - grid_range[0]) / grid_size\n","        grid = (\n","            (\n","                torch.arange(-spline_order, grid_size + spline_order + 1) * h\n","                + grid_range[0]\n","            )\n","            .expand(in_features, -1)\n","            .contiguous()\n","        )\n","        self.register_buffer(\"grid\", grid)\n","\n","        self.base_weight = torch.nn.Parameter(torch.Tensor(out_features, in_features))\n","        self.spline_weight = torch.nn.Parameter(\n","            torch.Tensor(out_features, in_features, grid_size + spline_order)\n","        )\n","        if enable_standalone_scale_spline:\n","            self.spline_scaler = torch.nn.Parameter(\n","                torch.Tensor(out_features, in_features)\n","            )\n","\n","        self.scale_noise = scale_noise\n","        self.scale_base = scale_base\n","        self.scale_spline = scale_spline\n","        self.enable_standalone_scale_spline = enable_standalone_scale_spline\n","        self.base_activation = base_activation()\n","        self.grid_eps = grid_eps\n","\n","        self.reset_parameters()\n","\n","    def reset_parameters(self):\n","        torch.nn.init.kaiming_uniform_(self.base_weight, a=math.sqrt(5) * self.scale_base)\n","        with torch.no_grad():\n","            noise = (\n","                (\n","                    torch.rand(self.grid_size + 1, self.in_features, self.out_features)\n","                    - 1 / 2\n","                )\n","                * self.scale_noise\n","                / self.grid_size\n","            )\n","            self.spline_weight.data.copy_(\n","                (self.scale_spline if not self.enable_standalone_scale_spline else 1.0)\n","                * self.curve2coeff(\n","                    self.grid.T[self.spline_order : -self.spline_order],\n","                    noise,\n","                )\n","            )\n","            if self.enable_standalone_scale_spline:\n","                # torch.nn.init.constant_(self.spline_scaler, self.scale_spline)\n","                torch.nn.init.kaiming_uniform_(self.spline_scaler, a=math.sqrt(5) * self.scale_spline)\n","\n","    def b_splines(self, x: torch.Tensor):\n","        \"\"\"\n","        Compute the B-spline bases for the given input tensor.\n","\n","        Args:\n","            x (torch.Tensor): Input tensor of shape (batch_size, in_features).\n","\n","        Returns:\n","            torch.Tensor: B-spline bases tensor of shape (batch_size, in_features, grid_size + spline_order).\n","        \"\"\"\n","        assert x.dim() == 2 and x.size(1) == self.in_features\n","\n","        grid: torch.Tensor = (\n","            self.grid\n","        )  # (in_features, grid_size + 2 * spline_order + 1)\n","        x = x.unsqueeze(-1)\n","        bases = ((x >= grid[:, :-1]) & (x < grid[:, 1:])).to(x.dtype)\n","        for k in range(1, self.spline_order + 1):\n","            bases = (\n","                (x - grid[:, : -(k + 1)])\n","                / (grid[:, k:-1] - grid[:, : -(k + 1)])\n","                * bases[:, :, :-1]\n","            ) + (\n","                (grid[:, k + 1 :] - x)\n","                / (grid[:, k + 1 :] - grid[:, 1:(-k)])\n","                * bases[:, :, 1:]\n","            )\n","\n","        assert bases.size() == (\n","            x.size(0),\n","            self.in_features,\n","            self.grid_size + self.spline_order,\n","        )\n","        return bases.contiguous()\n","\n","    def curve2coeff(self, x: torch.Tensor, y: torch.Tensor):\n","        \"\"\"\n","        Compute the coefficients of the curve that interpolates the given points.\n","\n","        Args:\n","            x (torch.Tensor): Input tensor of shape (batch_size, in_features).\n","            y (torch.Tensor): Output tensor of shape (batch_size, in_features, out_features).\n","\n","        Returns:\n","            torch.Tensor: Coefficients tensor of shape (out_features, in_features, grid_size + spline_order).\n","        \"\"\"\n","        assert x.dim() == 2 and x.size(1) == self.in_features\n","        assert y.size() == (x.size(0), self.in_features, self.out_features)\n","\n","        A = self.b_splines(x).transpose(\n","            0, 1\n","        )  # (in_features, batch_size, grid_size + spline_order)\n","        B = y.transpose(0, 1)  # (in_features, batch_size, out_features)\n","        solution = torch.linalg.lstsq(\n","            A, B\n","        ).solution  # (in_features, grid_size + spline_order, out_features)\n","        result = solution.permute(\n","            2, 0, 1\n","        )  # (out_features, in_features, grid_size + spline_order)\n","\n","        assert result.size() == (\n","            self.out_features,\n","            self.in_features,\n","            self.grid_size + self.spline_order,\n","        )\n","        return result.contiguous()\n","\n","    @property\n","    def scaled_spline_weight(self):\n","        return self.spline_weight * (\n","            self.spline_scaler.unsqueeze(-1)\n","            if self.enable_standalone_scale_spline\n","            else 1.0\n","        )\n","\n","    def forward(self, x: torch.Tensor):\n","        assert x.dim() == 2 and x.size(1) == self.in_features\n","\n","        base_output = F.linear(self.base_activation(x), self.base_weight)\n","        spline_output = F.linear(\n","            self.b_splines(x).view(x.size(0), -1),\n","            self.scaled_spline_weight.view(self.out_features, -1),\n","        )\n","        return base_output + spline_output\n","\n","    @torch.no_grad()\n","    def update_grid(self, x: torch.Tensor, margin=0.01):\n","        assert x.dim() == 2 and x.size(1) == self.in_features\n","        batch = x.size(0)\n","\n","        splines = self.b_splines(x)  # (batch, in, coeff)\n","        splines = splines.permute(1, 0, 2)  # (in, batch, coeff)\n","        orig_coeff = self.scaled_spline_weight  # (out, in, coeff)\n","        orig_coeff = orig_coeff.permute(1, 2, 0)  # (in, coeff, out)\n","        unreduced_spline_output = torch.bmm(splines, orig_coeff)  # (in, batch, out)\n","        unreduced_spline_output = unreduced_spline_output.permute(\n","            1, 0, 2\n","        )  # (batch, in, out)\n","\n","        # sort each channel individually to collect data distribution\n","        x_sorted = torch.sort(x, dim=0)[0]\n","        grid_adaptive = x_sorted[\n","            torch.linspace(\n","                0, batch - 1, self.grid_size + 1, dtype=torch.int64, device=x.device\n","            )\n","        ]\n","\n","        uniform_step = (x_sorted[-1] - x_sorted[0] + 2 * margin) / self.grid_size\n","        grid_uniform = (\n","            torch.arange(\n","                self.grid_size + 1, dtype=torch.float32, device=x.device\n","            ).unsqueeze(1)\n","            * uniform_step\n","            + x_sorted[0]\n","            - margin\n","        )\n","\n","        grid = self.grid_eps * grid_uniform + (1 - self.grid_eps) * grid_adaptive\n","        grid = torch.concatenate(\n","            [\n","                grid[:1]\n","                - uniform_step\n","                * torch.arange(self.spline_order, 0, -1, device=x.device).unsqueeze(1),\n","                grid,\n","                grid[-1:]\n","                + uniform_step\n","                * torch.arange(1, self.spline_order + 1, device=x.device).unsqueeze(1),\n","            ],\n","            dim=0,\n","        )\n","\n","        self.grid.copy_(grid.T)\n","        self.spline_weight.data.copy_(self.curve2coeff(x, unreduced_spline_output))\n","\n","    def regularization_loss(self, regularize_activation=1.0, regularize_entropy=1.0):\n","        \"\"\"\n","        Compute the regularization loss.\n","\n","        This is a dumb simulation of the original L1 regularization as stated in the\n","        paper, since the original one requires computing absolutes and entropy from the\n","        expanded (batch, in_features, out_features) intermediate tensor, which is hidden\n","        behind the F.linear function if we want an memory efficient implementation.\n","\n","        The L1 regularization is now computed as mean absolute value of the spline\n","        weights. The authors implementation also includes this term in addition to the\n","        sample-based regularization.\n","        \"\"\"\n","        l1_fake = self.spline_weight.abs().mean(-1)\n","        regularization_loss_activation = l1_fake.sum()\n","        p = l1_fake / regularization_loss_activation\n","        regularization_loss_entropy = -torch.sum(p * p.log())\n","        return (\n","            regularize_activation * regularization_loss_activation\n","            + regularize_entropy * regularization_loss_entropy\n","        )\n","\n","\n","class KAN(torch.nn.Module):\n","    def __init__(\n","        self,\n","        layers_hidden,\n","        grid_size=5,\n","        spline_order=3,\n","        scale_noise=0.1,\n","        scale_base=1.0,\n","        scale_spline=1.0,\n","        base_activation=torch.nn.SiLU,\n","        grid_eps=0.02,\n","        grid_range=[-1, 1],\n","    ):\n","        super(KAN, self).__init__()\n","        self.grid_size = grid_size\n","        self.spline_order = spline_order\n","\n","        self.layers = torch.nn.ModuleList()\n","        for in_features, out_features in zip(layers_hidden, layers_hidden[1:]):\n","            self.layers.append(\n","                KANLinear(\n","                    in_features,\n","                    out_features,\n","                    grid_size=grid_size,\n","                    spline_order=spline_order,\n","                    scale_noise=scale_noise,\n","                    scale_base=scale_base,\n","                    scale_spline=scale_spline,\n","                    base_activation=base_activation,\n","                    grid_eps=grid_eps,\n","                    grid_range=grid_range,\n","                )\n","            )\n","\n","    def forward(self, x: torch.Tensor, update_grid=False):\n","        for layer in self.layers:\n","            if update_grid:\n","                layer.update_grid(x)\n","            x = layer(x)\n","        return x\n","\n","    def regularization_loss(self, regularize_activation=1.0, regularize_entropy=1.0):\n","        return sum(\n","            layer.regularization_loss(regularize_activation, regularize_entropy)\n","            for layer in self.layers\n","        )"],"metadata":{"id":"8Hla0PmO3U6X","executionInfo":{"status":"ok","timestamp":1715120593563,"user_tz":-330,"elapsed":6,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}}},"execution_count":2,"outputs":[]},{"cell_type":"code","source":["vocab = ['a','b','c']\n","\n","words = []\n","for i in vocab:\n","  for j in vocab:\n","    for k in vocab:\n","      words.append(i+j+k)\n","\n","\n","print('words',words)\n","vocab.append('0')\n","print('vocab',vocab)\n","\n","letter_to_index = {letter: index for index, letter in enumerate(vocab)}\n","index_to_letter = {index: letter for index, letter in enumerate(vocab)}\n","\n","word_to_index = {word: index for index, word in enumerate(words)}\n","index_to_word = {index: word for index, word in enumerate(words)}\n","\n","\n","\n","#print(letter_to_index)\n","#print(index_to_letter)\n","\n","#print(word_to_index)\n","#print(index_to_word)\n","\n","N = len(words)\n","# includes special end of word character\n","V = len(vocab)\n","# includes end of word character\n","L = max(len(word) for word in words)+1\n","\n","print('# of words',N)\n","print('# of chars',V)\n","print('seq len', L)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"esgvDr19Pyu4","executionInfo":{"status":"ok","timestamp":1715120593563,"user_tz":-330,"elapsed":5,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}},"outputId":"4fce3e48-fe9c-4d52-cef6-258b9efd9091"},"execution_count":3,"outputs":[{"output_type":"stream","name":"stdout","text":["words ['aaa', 'aab', 'aac', 'aba', 'abb', 'abc', 'aca', 'acb', 'acc', 'baa', 'bab', 'bac', 'bba', 'bbb', 'bbc', 'bca', 'bcb', 'bcc', 'caa', 'cab', 'cac', 'cba', 'cbb', 'cbc', 'cca', 'ccb', 'ccc']\n","vocab ['a', 'b', 'c', '0']\n","# of words 27\n","# of chars 4\n","seq len 4\n"]}]},{"cell_type":"code","source":["# Define the dimensions\n","# Prepare training set\n","X_train = []\n","Y_train = []\n","\n","for word in words:\n","\n","    chars = list(word)\n","    x = torch.zeros(1, L, N)\n","    y = torch.zeros(1, L)\n","\n","    n = len(chars)\n","    for i in range(L):\n","        x[0, i, word_to_index[word]] = 1\n","        if i < n:\n","            y[0,i] = letter_to_index[chars[i]]\n","        else:\n","            y[0,i] = V-1\n","\n","    X_train.append(x)\n","    Y_train.append(y)\n","\n","# Convert the training set to tensors\n","X_train = torch.cat(X_train, dim=0)\n","Y_train = torch.cat(Y_train, dim=0)\n","\n","# Print the shape of the training set\n","print(\"X_train shape:\", X_train.shape)\n","print(\"Y_train shape:\", Y_train.shape)\n","# prepare training set\n","\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"jV1wAqYjPaGT","executionInfo":{"status":"ok","timestamp":1715120593564,"user_tz":-330,"elapsed":5,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}},"outputId":"8726fc5d-f544-4309-c82b-6b8119067664"},"execution_count":4,"outputs":[{"output_type":"stream","name":"stdout","text":["X_train shape: torch.Size([27, 4, 27])\n","Y_train shape: torch.Size([27, 4])\n"]}]},{"cell_type":"code","source":["# https://github.com/KasperGroesLudvigsen/influenza_transformer/blob/main/positional_encoder.py\n","\n","class MLP(nn.Module):\n","    def __init__(self, input_size, hidden_sizes, output_size):\n","        super(MLP, self).__init__()\n","        self.input_size = input_size\n","        self.hidden_sizes = hidden_sizes\n","        self.output_size = output_size\n","\n","        layers = []\n","        prev_size = input_size\n","        for size in hidden_sizes:\n","            layers.append(nn.Linear(prev_size, size))\n","            layers.append(nn.ReLU())\n","            prev_size = size\n","        layers.append(nn.Linear(prev_size, output_size))\n","\n","        self.model = nn.Sequential(*layers)\n","\n","    def forward(self, x):\n","        return self.model(x)\n","\n","class PositionalEncoder(nn.Module):\n","    \"\"\"\n","    The authors of the original transformer paper describe very succinctly what\n","    the positional encoding layer does and why it is needed:\n","\n","    \"Since our model contains no recurrence and no convolution, in order for the\n","    model to make use of the order of the sequence, we must inject some\n","    information about the relative or absolute position of the tokens in the\n","    sequence.\" (Vaswani et al, 2017)\n","    Adapted from:\n","    https://pytorch.org/tutorials/beginner/transformer_tutorial.html\n","    \"\"\"\n","\n","    def __init__(\n","        self,\n","        dropout: float=0.1,\n","        max_seq_len: int=100,\n","        d_model: int=512,\n","        batch_first: bool=True\n","        ):\n","\n","        \"\"\"\n","        Parameters:\n","            dropout: the dropout rate\n","            max_seq_len: the maximum length of the input sequences\n","            d_model: The dimension of the output of sub-layers in the model\n","                     (Vaswani et al, 2017)\n","        \"\"\"\n","\n","        super().__init__()\n","\n","        self.d_model = d_model\n","\n","        self.dropout = nn.Dropout(p=dropout)\n","\n","        self.batch_first = batch_first\n","\n","        # adapted from PyTorch tutorial\n","        position = torch.arange(max_seq_len).unsqueeze(1)\n","\n","\n","        div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))\n","\n","\n","        if self.batch_first:\n","\n","            pe = torch.zeros(1, max_seq_len, d_model)\n","\n","            pe[0, :, 0::2] = torch.sin(position * div_term)\n","\n","            pe[0, :, 1::2] = torch.cos(position * div_term)[:,:(d_model//2)]\n","\n","\n","        else:\n","            pe = torch.zeros(max_seq_len, 1, d_model)\n","\n","            pe[:, 0, 0::2] = torch.sin(position * div_term)\n","\n","            pe[:, 0, 1::2] = torch.cos(position * div_term)\n","\n","        self.register_buffer('pe', pe)\n","\n","    def forward(self, x: Tensor) -> Tensor:\n","        \"\"\"\n","        Args:\n","            x: Tensor, shape [batch_size, enc_seq_len, dim_val] or\n","               [enc_seq_len, batch_size, dim_val]\n","        \"\"\"\n","        if self.batch_first:\n","            x = x + self.pe[:,:x.size(1)]\n","        else:\n","            x = x + self.pe[:x.size(0)]\n","\n","        return self.dropout(x)\n","\n","class myRNN(nn.Module):\n","    def __init__(self, input_size, hidden_size, num_classes, num_layers=1, max_seq_len=L, MLP_hidden_sizes=[10,10], head='MLP'):\n","        super(myRNN, self).__init__()\n","        self.input_size = input_size\n","        self.pos_encoder = PositionalEncoder(d_model = input_size, dropout=0.1, max_seq_len=max_seq_len)\n","        self.hidden_size = hidden_size\n","        self.rnn = nn.RNN(input_size, hidden_size, num_layers,batch_first=True)\n","        self.head = nn.Linear(hidden_size, num_classes)\n","\n","        if head == 'MLP':\n","          self.head = MLP(hidden_size, MLP_hidden_sizes, num_classes)\n","        elif head == 'KAN':\n","          self.head = KAN([hidden_size]+MLP_hidden_sizes+[num_classes])\n","        else:\n","          pass\n","\n","\n","\n","\n","\n","    def forward(self, x):\n","        # Initialize hidden state with zeros\n","        # h0 = torch.zeros(1, x.size(0), self.hidden_size).to(x.device)\n","\n","        #h0 can be improved (h0 = x*toen_embedding)\n","\n","        # Forward pass through RNN\n","        #out, _ = self.rnn(x, h0)\n","        x = x * math.sqrt(self.input_size)\n","        x = self.pos_encoder(x)\n","        out, _ = self.rnn(x)\n","\n","        # Concatenate the output of RNN with y\n","        #out = torch.cat((out[:, -1, :], y.unsqueeze(1)), dim=1)\n","        # out = out[:, -1, :]\n","\n","        # Pass the concatenated output through the fully connected layer\n","\n","        shape = out.shape\n","        out = out.reshape(shape[0]*shape[1],shape[2])\n","        out = self.head(out)\n","\n","        return out"],"metadata":{"id":"ZrOoXs-bPxEv","executionInfo":{"status":"ok","timestamp":1715120593564,"user_tz":-330,"elapsed":4,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}}},"execution_count":5,"outputs":[]},{"cell_type":"code","source":["# Train the model\n","def trainer(X_train, Y_train,batch_size, model):\n","  loss_acc = []\n","  criterion = nn.CrossEntropyLoss()\n","  optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n","\n","  for epoch in range(num_epochs):\n","      # Shuffle the training data\n","      indices = torch.randperm(X_train.size(0))\n","      X_train_shuffled = X_train[indices]\n","      Y_train_shuffled = Y_train[indices]\n","\n","      # Split the training data into batches\n","      num_batches = X_train.size(0) // batch_size\n","      for batch_idx in range(num_batches):\n","          # Get the batch inputs and targets\n","          start_idx = batch_idx * batch_size\n","          end_idx = start_idx + batch_size\n","          batch_inputs = X_train_shuffled[start_idx:end_idx]\n","          batch_targets = Y_train_shuffled[start_idx:end_idx]\n","\n","          # Forward pass\n","          outputs = model(batch_inputs)\n","          shape = outputs.shape\n","          outputs = outputs.reshape(shape[0]//L,L,shape[1])\n","\n","          # Compute the loss\n","          loss = criterion(outputs.view(-1, num_classes), batch_targets.view(-1).long())\n","\n","          # Backward pass and optimization\n","          optimizer.zero_grad()\n","          loss.backward()\n","          optimizer.step()\n","\n","      # Print the loss for this epoch\n","      #print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item()}\")\n","      loss_acc.append(loss.item())\n","  return loss_acc, model\n","\n","def Detokenise(X, model):\n","  with torch.no_grad():\n","    outputs = model(X)\n","    shape = outputs.shape\n","    outputs = outputs.reshape(shape[0]//L,L,shape[1])\n","  predicted_words = []\n","\n","  for output in outputs:\n","    predicted_word = ''\n","    for i in range(L):\n","      index = torch.argmax(output[i])\n","      if index == V-1:\n","        break\n","      predicted_word += index_to_letter[index.item()]\n","    predicted_words.append(predicted_word)\n","  return predicted_words\n","\n","def getAcc(test_word_ids, predicted_words):\n","  acc = 0\n","  for i in range(len(test_word_ids)):\n","    w = words[test_word_ids[i]]\n","    wh = predicted_words[i]\n","    acc += w==wh\n","    print(w,wh, w==wh)\n","  return 100*acc/N"],"metadata":{"id":"Jx-QEMVQfqlh","executionInfo":{"status":"ok","timestamp":1715120593564,"user_tz":-330,"elapsed":4,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}}},"execution_count":6,"outputs":[]},{"cell_type":"code","source":["input_size = N\n","hidden_size = 5*V\n","num_classes = V\n","num_layers = 3\n","num_epochs = 1000\n","batch_size = 15\n","MLP_hidden_sizes = [5*V,5*V]\n","lr = 0.001"],"metadata":{"id":"rr9eNxLlJu3C","executionInfo":{"status":"ok","timestamp":1715120593564,"user_tz":-330,"elapsed":3,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}}},"execution_count":7,"outputs":[]},{"cell_type":"code","source":["# Create an instance of the RNN model\n","model = myRNN(input_size, hidden_size, num_classes, num_layers=num_layers, max_seq_len=L,MLP_hidden_sizes=MLP_hidden_sizes, head='MLP')\n","print(model)\n","\n","loss_acc_mlp, model = trainer(X_train, Y_train, batch_size, model)\n","plt.plot(loss_acc_mlp)\n","\n","test_word_ids= list(range(0, N))\n","X_test = X_train[test_word_ids]\n","\n","model.eval()\n","\n","predicted_words = Detokenise(X_test,model)\n","acc = getAcc(test_word_ids, predicted_words)\n","print('acc is',acc)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"tiUkNdibF-oS","executionInfo":{"status":"ok","timestamp":1715120612332,"user_tz":-330,"elapsed":18771,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}},"outputId":"e2d3d014-145a-491f-bdb0-af1a8edafa3a"},"execution_count":8,"outputs":[{"output_type":"stream","name":"stdout","text":["myRNN(\n","  (pos_encoder): PositionalEncoder(\n","    (dropout): Dropout(p=0.1, inplace=False)\n","  )\n","  (rnn): RNN(27, 20, num_layers=3, batch_first=True)\n","  (head): MLP(\n","    (model): Sequential(\n","      (0): Linear(in_features=20, out_features=20, bias=True)\n","      (1): ReLU()\n","      (2): Linear(in_features=20, out_features=20, bias=True)\n","      (3): ReLU()\n","      (4): Linear(in_features=20, out_features=4, bias=True)\n","    )\n","  )\n",")\n","aaa aaa True\n","aab aab True\n","aac aac True\n","aba aba True\n","abb abb True\n","abc abc True\n","aca aca True\n","acb acb True\n","acc acc True\n","baa baa True\n","bab bab True\n","bac bac True\n","bba bba True\n","bbb bbb True\n","bbc bbc True\n","bca bca True\n","bcb bcb True\n","bcc bcc True\n","caa caa True\n","cab cab True\n","cac cac True\n","cba cba True\n","cbb cbb True\n","cbc cbc True\n","cca cca True\n","ccb ccb True\n","ccc ccc True\n","acc is 100.0\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":["# Create an instance of the RNN model\n","kan = myRNN(input_size, hidden_size, num_classes, num_layers=num_layers, max_seq_len=L,MLP_hidden_sizes=MLP_hidden_sizes, head='KAN')\n","print(kan)\n","\n","loss_acc_kan, kan = trainer(X_train, Y_train, batch_size, kan)\n","plt.plot(loss_acc_kan)\n","\n","test_word_ids= list(range(0, N))\n","X_test = X_train[test_word_ids]\n","\n","kan.eval()\n","\n","predicted_words = Detokenise(X_test,kan)\n","acc = getAcc(test_word_ids, predicted_words)\n","print('acc is',acc)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":1000},"id":"pMVrvMhBHrTh","executionInfo":{"status":"ok","timestamp":1715120622831,"user_tz":-330,"elapsed":10502,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}},"outputId":"bd0644bb-0d33-48bd-f025-a007eef24205"},"execution_count":9,"outputs":[{"output_type":"stream","name":"stdout","text":["myRNN(\n","  (pos_encoder): PositionalEncoder(\n","    (dropout): Dropout(p=0.1, inplace=False)\n","  )\n","  (rnn): RNN(27, 20, num_layers=3, batch_first=True)\n","  (head): KAN(\n","    (layers): ModuleList(\n","      (0-2): 3 x KANLinear(\n","        (base_activation): SiLU()\n","      )\n","    )\n","  )\n",")\n","aaa aaa True\n","aab aab True\n","aac aac True\n","aba aba True\n","abb abb True\n","abc abc True\n","aca aca True\n","acb acb True\n","acc acc True\n","baa baa True\n","bab bab True\n","bac bac True\n","bba bba True\n","bbb bbb True\n","bbc bbc True\n","bca bca True\n","bcb bcb True\n","bcc bcc True\n","caa caa True\n","cab cab True\n","cac cac True\n","cba cba True\n","cbb cbb True\n","cbc cbc True\n","cca cca True\n","ccb ccb True\n","ccc ccc True\n","acc is 100.0\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":["plt.plot(loss_acc_mlp,label='rnn-mlp')\n","plt.plot(loss_acc_kan,label='rnn-kan')\n","plt.legend(loc='best')\n","plt.xlabel('epochs')\n","plt.ylabel('loss')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":467},"id":"RYqeTOCjIOTY","executionInfo":{"status":"ok","timestamp":1715121402426,"user_tz":-330,"elapsed":1853,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}},"outputId":"1be64b53-bada-4eaf-9e59-7f173d62de93"},"execution_count":13,"outputs":[{"output_type":"execute_result","data":{"text/plain":["Text(0, 0.5, 'loss')"]},"metadata":{},"execution_count":13},{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":[],"metadata":{"id":"PZKI0pv_IPNA","executionInfo":{"status":"ok","timestamp":1715120622831,"user_tz":-330,"elapsed":4,"user":{"displayName":"soma dhavala","userId":"15308128232301337351"}}},"execution_count":10,"outputs":[]}]}