{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## **Midterm: Neural Network-Based Language Model for Next Token Prediction**"
      ],
      "metadata": {
        "id": "2Nv6Kc_l3zCX"
      },
      "id": "2Nv6Kc_l3zCX"
    },
    {
      "cell_type": "markdown",
      "source": [
        " 1.Imports and Hyperparameters"
      ],
      "metadata": {
        "id": "eUyzWMzP0eeW"
      },
      "id": "eUyzWMzP0eeW"
    },
    {
      "cell_type": "code",
      "source": [
        "# 1. Imports\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# 2. Hyperparameters\n",
        "num_epochs = 25\n",
        "batch_size = 5\n",
        "learning_rate = 0.001\n",
        "embedding_dim = 128\n",
        "hidden_dim = 256\n",
        "seq_length = 6  # Sequence length for input to the model\n"
      ],
      "metadata": {
        "id": "rxed4XpM0cO_"
      },
      "id": "rxed4XpM0cO_",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Data Loading"
      ],
      "metadata": {
        "id": "-JkC1rPb0pNO"
      },
      "id": "-JkC1rPb0pNO"
    },
    {
      "cell_type": "code",
      "source": [
        "# 3. Data Loading\n",
        "class TextDataset:\n",
        "    def __init__(self, file_path):\n",
        "        self.data = pd.read_csv(file_path)\n",
        "\n",
        "    def get_texts(self):\n",
        "        # Extract 'input' column from the dataset\n",
        "        return self.data['input'].tolist()\n",
        "\n",
        "# Load datasets\n",
        "english_dataset = TextDataset('english_dataset_subset.csv')\n",
        "finnish_dataset = TextDataset('finnish_dataset_subset.csv')\n",
        "\n",
        "# Combine data\n",
        "combined_data = english_dataset.get_texts() + finnish_dataset.get_texts()\n",
        "print(f\"Loaded {len(combined_data)} sentences from English and Finnish datasets.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eY_LHUZu0cK9",
        "outputId": "bea3fff3-dc9d-4dcf-b2ce-8f2802144496"
      },
      "id": "eY_LHUZu0cK9",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loaded 200 sentences from English and Finnish datasets.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. Tokenization"
      ],
      "metadata": {
        "id": "KPe2qAsm02rB"
      },
      "id": "KPe2qAsm02rB"
    },
    {
      "cell_type": "code",
      "source": [
        "# 4. Tokenization\n",
        "def tokenize(text):\n",
        "    if isinstance(text, str):  # Check if the text is a string\n",
        "        return text.split()  # Simple whitespace tokenization\n",
        "    else:\n",
        "        return []  # Return an empty list for non-string entries\n",
        "\n",
        "# Tokenizing data\n",
        "tokenized_data = [tokenize(text) for text in combined_data]\n",
        "print(f\"Tokenized {len(tokenized_data)} sentences.\")\n",
        "\n",
        "# Filter out any empty lists (from non-string entries)\n",
        "tokenized_data = [tokens for tokens in tokenized_data if tokens]\n",
        "print(f\"After filtering, {len(tokenized_data)} valid tokenized sentences.\")\n",
        "\n",
        "# Create a vocabulary\n",
        "vocab = set(word for sentence in tokenized_data for word in sentence)\n",
        "word_to_index = {word: idx for idx, word in enumerate(vocab)}\n",
        "index_to_word = {idx: word for word, idx in word_to_index.items()}\n",
        "print(f\"Created vocabulary of size {len(vocab)}.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bBV8BR6n0cFC",
        "outputId": "8a187987-fea8-4229-94b0-c896e59150e2"
      },
      "id": "bBV8BR6n0cFC",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tokenized 200 sentences.\n",
            "After filtering, 138 valid tokenized sentences.\n",
            "Created vocabulary of size 1958.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. Encoding Data"
      ],
      "metadata": {
        "id": "nfdJoRBs1bbn"
      },
      "id": "nfdJoRBs1bbn"
    },
    {
      "cell_type": "code",
      "source": [
        "# 5. Convert text data to numerical format\n",
        "def encode_data(tokenized_data):\n",
        "    encoded_data = []\n",
        "    for sentence in tokenized_data:\n",
        "        encoded_sentence = [word_to_index[word] for word in sentence if word in word_to_index]\n",
        "        encoded_data.append(encoded_sentence)\n",
        "    return encoded_data\n",
        "\n",
        "encoded_data = encode_data(tokenized_data)\n",
        "print(f\"Encoded {len(encoded_data)} sentences into numerical format.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1Op2gQ8K0cBO",
        "outputId": "ce1beee2-741a-4e82-f9ac-1fda37b638da"
      },
      "id": "1Op2gQ8K0cBO",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Encoded 138 sentences into numerical format.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5. Create Sequences for Training"
      ],
      "metadata": {
        "id": "QEAmowNl1kGX"
      },
      "id": "QEAmowNl1kGX"
    },
    {
      "cell_type": "code",
      "source": [
        "# 6. Prepare training and validation data\n",
        "def create_sequences(encoded_data, seq_length):\n",
        "    sequences = []\n",
        "    for sentence in encoded_data:\n",
        "        for i in range(len(sentence) - seq_length):\n",
        "            sequences.append(sentence[i:i + seq_length + 1])\n",
        "    return sequences\n",
        "\n",
        "sequences = create_sequences(encoded_data, seq_length)\n",
        "print(f\"Created {len(sequences)} sequences of length {seq_length + 1}.\")\n",
        "\n",
        "# Split into train and validation sets\n",
        "train_size = int(0.8 * len(sequences))\n",
        "train_data = sequences[:train_size]\n",
        "val_data = sequences[train_size:]\n",
        "\n",
        "print(f\"Split data into {len(train_data)} training sequences and {len(val_data)} validation sequences.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yIV12Je31qRz",
        "outputId": "dca70f8c-cfd0-46a0-eec7-4a651edf4297"
      },
      "id": "yIV12Je31qRz",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Created 5460 sequences of length 7.\n",
            "Split data into 4368 training sequences and 1092 validation sequences.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "6. Model Definition"
      ],
      "metadata": {
        "id": "l8chzMHV10ff"
      },
      "id": "l8chzMHV10ff"
    },
    {
      "cell_type": "code",
      "source": [
        "# 7. Model Definition\n",
        "class LSTMModel(nn.Module):\n",
        "    def __init__(self, vocab_size, embedding_dim, hidden_dim):\n",
        "        super(LSTMModel, self).__init__()\n",
        "        self.embedding = nn.Embedding(vocab_size, embedding_dim)\n",
        "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)\n",
        "        self.fc = nn.Linear(hidden_dim, vocab_size)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.embedding(x)\n",
        "        x, _ = self.lstm(x)\n",
        "        x = self.fc(x[:, -1, :])  # Get the output from the last time step\n",
        "        return x\n",
        "\n",
        "# Initialize the model\n",
        "model = LSTMModel(len(vocab), embedding_dim, hidden_dim)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
        "print(\"Initialized LSTM model.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uIeJGPhU1qOb",
        "outputId": "42416f2e-4f44-4b47-e94a-95296a2903bd"
      },
      "id": "uIeJGPhU1qOb",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Initialized LSTM model.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "7. Training Loop"
      ],
      "metadata": {
        "id": "OcIgDDfi17GW"
      },
      "id": "OcIgDDfi17GW"
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# 8. Training Loop\n",
        "def train(model, train_data, val_data, criterion, optimizer, num_epochs):\n",
        "    model.train()\n",
        "    train_losses = []\n",
        "    val_losses = []\n",
        "    perplexities = []\n",
        "\n",
        "    for epoch in range(num_epochs):\n",
        "        total_train_loss = 0\n",
        "        total_val_loss = 0\n",
        "\n",
        "        # Training Phase\n",
        "        for i in range(0, len(train_data), batch_size):\n",
        "            inputs = torch.tensor([train_data[j][:-1] for j in range(i, min(i + batch_size, len(train_data)))], dtype=torch.long)\n",
        "            targets = torch.tensor([train_data[j][-1] for j in range(i, min(i + batch_size, len(train_data)))], dtype=torch.long)\n",
        "\n",
        "            optimizer.zero_grad()\n",
        "            output = model(inputs)\n",
        "            loss = criterion(output, targets)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            total_train_loss += loss.item()\n",
        "\n",
        "        avg_train_loss = total_train_loss / (len(train_data) // batch_size)\n",
        "        train_losses.append(avg_train_loss)\n",
        "\n",
        "        # Validation Phase\n",
        "        model.eval()\n",
        "        with torch.no_grad():\n",
        "            for i in range(0, len(val_data), batch_size):\n",
        "                inputs = torch.tensor([val_data[j][:-1] for j in range(i, min(i + batch_size, len(val_data)))], dtype=torch.long)\n",
        "                targets = torch.tensor([val_data[j][-1] for j in range(i, min(i + batch_size, len(val_data)))], dtype=torch.long)\n",
        "\n",
        "                output = model(inputs)\n",
        "                loss = criterion(output, targets)\n",
        "                total_val_loss += loss.item()\n",
        "\n",
        "        avg_val_loss = total_val_loss / (len(val_data) // batch_size)\n",
        "        val_losses.append(avg_val_loss)\n",
        "\n",
        "        # Calculate perplexity\n",
        "        perplexity = np.exp(avg_val_loss)  # Calculate perplexity\n",
        "        perplexities.append(perplexity)\n",
        "\n",
        "        print(f'Epoch [{epoch + 1}/{num_epochs}], Train Loss: {avg_train_loss:.4f}, Val Loss: {avg_val_loss:.4f}, Perplexity: {perplexity:.4f}')\n",
        "\n",
        "        # Save checkpoint every 5 epochs\n",
        "        if (epoch + 1) % 5 == 0:\n",
        "            checkpoint_path = f'checkpoint_epoch_{epoch + 1}.pt'\n",
        "            torch.save({\n",
        "                'epoch': epoch + 1,\n",
        "                'model_state_dict': model.state_dict(),\n",
        "                'optimizer_state_dict': optimizer.state_dict(),\n",
        "                'train_losses': train_losses,\n",
        "                'val_losses': val_losses,\n",
        "                'perplexities': perplexities,\n",
        "            }, checkpoint_path)\n",
        "            print(f\"Checkpoint saved at epoch {epoch + 1} as '{checkpoint_path}'\")\n",
        "\n",
        "    return train_losses, val_losses, perplexities\n",
        "\n",
        "# Train the model\n",
        "train_losses, val_losses, perplexities = train(model, train_data, val_data, criterion, optimizer, num_epochs)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jjloo2nU4UeO",
        "outputId": "2e9a30f1-2423-46d6-d7ee-147d0db960e4"
      },
      "id": "Jjloo2nU4UeO",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/25], Train Loss: 6.8710, Val Loss: 6.8811, Perplexity: 973.6762\n",
            "Epoch [2/25], Train Loss: 5.1462, Val Loss: 7.6116, Perplexity: 2021.5649\n",
            "Epoch [3/25], Train Loss: 3.7673, Val Loss: 8.2986, Perplexity: 4018.3254\n",
            "Epoch [4/25], Train Loss: 2.4472, Val Loss: 8.7297, Perplexity: 6183.9161\n",
            "Epoch [5/25], Train Loss: 1.4478, Val Loss: 9.0060, Perplexity: 8152.1416\n",
            "Checkpoint saved at epoch 5 as 'checkpoint_epoch_5.pt'\n",
            "Epoch [6/25], Train Loss: 0.8094, Val Loss: 9.1132, Perplexity: 9074.2265\n",
            "Epoch [7/25], Train Loss: 0.4723, Val Loss: 9.4768, Perplexity: 13053.7107\n",
            "Epoch [8/25], Train Loss: 0.3649, Val Loss: 9.7469, Perplexity: 17100.9691\n",
            "Epoch [9/25], Train Loss: 0.2284, Val Loss: 10.0335, Perplexity: 22777.7760\n",
            "Epoch [10/25], Train Loss: 0.1159, Val Loss: 10.1731, Perplexity: 26189.3596\n",
            "Checkpoint saved at epoch 10 as 'checkpoint_epoch_10.pt'\n",
            "Epoch [11/25], Train Loss: 0.0509, Val Loss: 10.2586, Perplexity: 28525.5027\n",
            "Epoch [12/25], Train Loss: 0.0264, Val Loss: 10.3825, Perplexity: 32289.6129\n",
            "Epoch [13/25], Train Loss: 0.0181, Val Loss: 10.5873, Perplexity: 39628.3088\n",
            "Epoch [14/25], Train Loss: 0.0158, Val Loss: 10.6960, Perplexity: 44179.4129\n",
            "Epoch [15/25], Train Loss: 0.0131, Val Loss: 10.8721, Perplexity: 52686.5938\n",
            "Checkpoint saved at epoch 15 as 'checkpoint_epoch_15.pt'\n",
            "Epoch [16/25], Train Loss: 0.0111, Val Loss: 11.0015, Perplexity: 59967.0098\n",
            "Epoch [17/25], Train Loss: 0.1308, Val Loss: 10.2832, Perplexity: 29236.6510\n",
            "Epoch [18/25], Train Loss: 0.3088, Val Loss: 10.5067, Perplexity: 36558.5099\n",
            "Epoch [19/25], Train Loss: 0.0578, Val Loss: 10.7456, Perplexity: 46426.6651\n",
            "Epoch [20/25], Train Loss: 0.0143, Val Loss: 10.9940, Perplexity: 59516.3001\n",
            "Checkpoint saved at epoch 20 as 'checkpoint_epoch_20.pt'\n",
            "Epoch [21/25], Train Loss: 0.0097, Val Loss: 11.0602, Perplexity: 63590.8766\n",
            "Epoch [22/25], Train Loss: 0.0084, Val Loss: 11.1461, Perplexity: 69294.8322\n",
            "Epoch [23/25], Train Loss: 0.0084, Val Loss: 11.1882, Perplexity: 72274.7662\n",
            "Epoch [24/25], Train Loss: 0.0094, Val Loss: 11.4119, Perplexity: 90390.7318\n",
            "Epoch [25/25], Train Loss: 0.0077, Val Loss: 11.5032, Perplexity: 99031.4207\n",
            "Checkpoint saved at epoch 25 as 'checkpoint_epoch_25.pt'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "8. Saving Losses and Plotting"
      ],
      "metadata": {
        "id": "XmJt2apl2EBY"
      },
      "id": "XmJt2apl2EBY"
    },
    {
      "cell_type": "code",
      "source": [
        "#  Saving training and validation losses to CSV\n",
        "losses_df = pd.DataFrame({\n",
        "    'Epoch': range(1, num_epochs + 1),\n",
        "    'Training Loss': train_losses,\n",
        "    'Validation Loss': val_losses,\n",
        "    'Perplexity': perplexities\n",
        "})\n",
        "losses_df.to_csv('training_losses.csv', index=False)\n",
        "print(\"Saved training losses to 'training_losses.csv'.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YwbDdFgL1qJZ",
        "outputId": "28765dcf-30e9-440b-97e2-ad51b00b1f74"
      },
      "id": "YwbDdFgL1qJZ",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saved training losses to 'training_losses.csv'.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "9. Plotting the training and validation loss and perplexity"
      ],
      "metadata": {
        "id": "4VcmfIzC24hp"
      },
      "id": "4VcmfIzC24hp"
    },
    {
      "cell_type": "code",
      "source": [
        "# 9. Saving training and validation losses to CSV\n",
        "losses_df = pd.DataFrame({\n",
        "    'Epoch': range(1, num_epochs + 1),\n",
        "    'Training Loss': train_losses,\n",
        "    'Validation Loss': val_losses,\n",
        "    'Perplexity': perplexities\n",
        "})\n",
        "losses_df.to_csv('training_losses.csv', index=False)\n",
        "print(\"Saved training losses to 'training_losses.csv'.\")\n",
        "\n",
        "# 10. Plotting the training and validation loss\n",
        "plt.figure(figsize=(14, 8))\n",
        "\n",
        "# Plot for training and validation loss\n",
        "plt.plot(range(1, num_epochs + 1), train_losses, label='Training Loss', color='blue')\n",
        "plt.plot(range(1, num_epochs + 1), val_losses, label='Validation Loss', color='orange')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.legend()\n",
        "plt.grid(True)  # Add grid lines\n",
        "\n",
        "\n",
        "# Save the training and validation loss plot\n",
        "plt.tight_layout()\n",
        "plt.savefig('loss_plot.png')  # Save as a separate file\n",
        "plt.show()\n",
        "print(\"Loss plot saved as 'loss_plot.png'.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 583
        },
        "id": "GWFxGhLs2jKM",
        "outputId": "f19fa506-ab69-49dc-dc4a-fd1df64d4314"
      },
      "id": "GWFxGhLs2jKM",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saved training losses to 'training_losses.csv'.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1400x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loss plot saved as 'loss_plot.png'.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting perplexity\n",
        "plt.figure(figsize=(14, 8))\n",
        "\n",
        "# Plot for perplexity\n",
        "plt.plot(range(1, num_epochs + 1), perplexities, label='Perplexity', color='green')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Perplexity')\n",
        "plt.title('Perplexity Over Epochs')\n",
        "plt.legend()\n",
        "plt.grid(True)  # Add grid lines\n",
        "\n",
        "\n",
        "# Save the perplexity plot\n",
        "plt.tight_layout()\n",
        "plt.savefig('perplexity_plot.png')  # Save as a separate file\n",
        "plt.show()\n",
        "print(\"Perplexity plot saved as 'perplexity_plot.png'.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 566
        },
        "id": "rFv1DvZ32jH4",
        "outputId": "8c2225db-0a50-4568-dc0d-4373aa55ef77"
      },
      "id": "rFv1DvZ32jH4",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1400x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Perplexity plot saved as 'perplexity_plot.png'.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "10. Text Generation"
      ],
      "metadata": {
        "id": "9m8Cqrdn3CSb"
      },
      "id": "9m8Cqrdn3CSb"
    },
    {
      "cell_type": "code",
      "source": [
        "# 11. Text Generation Function\n",
        "def generate_text(model, start_text, gen_length):\n",
        "    model.eval()\n",
        "    generated_text = start_text\n",
        "    for _ in range(gen_length):\n",
        "        last_words = generated_text.split()[-seq_length:]\n",
        "        input_seq = torch.tensor(\n",
        "            [word_to_index[word] for word in last_words if word in word_to_index],\n",
        "            dtype=torch.long\n",
        "        ).unsqueeze(0)\n",
        "\n",
        "        if input_seq.size(1) == 0:\n",
        "            break  # Break the loop if there are no valid input sequences\n",
        "\n",
        "        with torch.no_grad():\n",
        "            output = model(input_seq)\n",
        "\n",
        "        next_word_idx = torch.argmax(output).item()\n",
        "        next_word = index_to_word[next_word_idx]\n",
        "        generated_text += ' ' + next_word\n",
        "\n",
        "    print(f\"Generated Text: {generated_text}\")\n",
        "    return generated_text\n",
        "\n",
        "# Generate text in English\n",
        "start_text_english = \"give three tips for staying healthy\"\n",
        "generated_english = generate_text(model, start_text_english, gen_length=50)\n",
        "\n",
        "# Generate text in Finnish\n",
        "start_text_finnish = \"anna kolme vinkkiä pysyäksesi terveenä\"\n",
        "generated_finnish = generate_text(model, start_text_finnish, gen_length=70)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GT6tZZ9SD-VW",
        "outputId": "b75010e5-4f20-4c6a-d5e5-938613fb0003"
      },
      "id": "GT6tZZ9SD-VW",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Generated Text: give three tips for staying healthy\n",
            "Generated Text: syö tasapainoista ja ravitsevaa ruokavaliota, muista sisällyttää hedelmiä ja vihanneksia\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "RqVig_jEEm8T"
      },
      "id": "RqVig_jEEm8T",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "J9MO4a9qEosY"
      },
      "id": "J9MO4a9qEosY",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "xnhNcLJaFkFR"
      },
      "id": "xnhNcLJaFkFR",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "4pFPV199Eoo5"
      },
      "id": "4pFPV199Eoo5",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "EWAeUETqEomR"
      },
      "id": "EWAeUETqEomR",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.12.4"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}