notebook-2-finetune.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyNVrlCGuO8bnf3jnI1ds8ok",
      "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/SandeepChatterjee66/NLP-Workshop24/blob/main/notebook-2-finetune.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install datasets"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "whDLy9nK493b",
        "outputId": "4f67a886-d6b4-4dc1-c72b-e3c7fce74a1a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: datasets in /usr/local/lib/python3.10/dist-packages (3.2.0)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from datasets) (3.16.1)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (1.26.4)\n",
            "Requirement already satisfied: pyarrow>=15.0.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (17.0.0)\n",
            "Requirement already satisfied: dill<0.3.9,>=0.3.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.3.8)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from datasets) (2.2.2)\n",
            "Requirement already satisfied: requests>=2.32.2 in /usr/local/lib/python3.10/dist-packages (from datasets) (2.32.3)\n",
            "Requirement already satisfied: tqdm>=4.66.3 in /usr/local/lib/python3.10/dist-packages (from datasets) (4.66.6)\n",
            "Requirement already satisfied: xxhash in /usr/local/lib/python3.10/dist-packages (from datasets) (3.5.0)\n",
            "Requirement already satisfied: multiprocess<0.70.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.70.16)\n",
            "Requirement already satisfied: fsspec<=2024.9.0,>=2023.1.0 in /usr/local/lib/python3.10/dist-packages (from fsspec[http]<=2024.9.0,>=2023.1.0->datasets) (2024.9.0)\n",
            "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from datasets) (3.11.10)\n",
            "Requirement already satisfied: huggingface-hub>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.26.5)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from datasets) (24.2)\n",
            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (6.0.2)\n",
            "Requirement already satisfied: aiohappyeyeballs>=2.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (2.4.4)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.3.1)\n",
            "Requirement already satisfied: async-timeout<6.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (4.0.3)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (24.2.0)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.5.0)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (6.1.0)\n",
            "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (0.2.1)\n",
            "Requirement already satisfied: yarl<2.0,>=1.17.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.18.3)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub>=0.23.0->datasets) (4.12.2)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.4.0)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2.2.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2024.8.30)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.2)\n",
            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas->datasets) (1.17.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "plipY2AW4TmT",
        "outputId": "3845037c-46db-4f74-cb41-882f672406ab"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device: cuda\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, Dataset\n",
        "from transformers import BertTokenizer, BertForSequenceClassification\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score, classification_report\n",
        "import numpy as np\n",
        "from datasets import load_dataset\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# 1. Check if GPU is available and set device\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(f\"Using device: {device}\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# 2. Load dataset using HuggingFace's datasets library\n",
        "dataset = load_dataset(\"imdb\")  # Use the IMDb movie review dataset\n",
        "\n",
        "import numpy as np\n",
        "from datasets import load_dataset\n",
        "from torch.utils.data import random_split\n",
        "\n",
        "# Load dataset\n",
        "dataset = load_dataset(\"imdb\")\n",
        "\n",
        "# Sample 10% from train and split test into 80% for test, 20% for validation\n",
        "train_data = list(zip(dataset['train']['text'], dataset['train']['label']))\n",
        "train_data_sampled = np.random.choice(len(train_data), size=int(len(train_data) * 0.1), replace=False)\n",
        "train_data_sampled = [train_data[i] for i in train_data_sampled]\n",
        "\n",
        "test_data = list(zip(dataset['test']['text'], dataset['test']['label']))\n",
        "val_size = int(len(test_data) * 0.2)\n",
        "test_data, val_data = random_split(test_data, [len(test_data) - val_size, val_size])\n",
        "\n",
        "# Unzip data into features and labels\n",
        "X_train, y_train = zip(*train_data_sampled)\n",
        "X_test, y_test = zip(*test_data)\n",
        "X_val, y_val = zip(*val_data)\n",
        "\n",
        "# Print lengths\n",
        "print(len(X_train), len(X_test), len(X_val))"
      ],
      "metadata": {
        "id": "uuyFVdRF4wZv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 3. Tokenization and Data Preparation\n",
        "class SentimentDataset(Dataset):\n",
        "    def __init__(self, texts, labels, tokenizer, max_len=128):\n",
        "        self.texts = texts\n",
        "        self.labels = labels\n",
        "        self.tokenizer = tokenizer\n",
        "        self.max_len = max_len\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.texts)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        text = self.texts[idx]\n",
        "        label = self.labels[idx]\n",
        "        encoding = self.tokenizer(\n",
        "            text,\n",
        "            max_length=self.max_len,\n",
        "            padding='max_length',\n",
        "            truncation=True,\n",
        "            return_tensors=\"pt\"\n",
        "        )\n",
        "        input_ids = encoding['input_ids'].squeeze(0)  # Remove batch dimension\n",
        "        attention_mask = encoding['attention_mask'].squeeze(0)  # Remove batch dimension\n",
        "        return input_ids, attention_mask, torch.tensor(label, dtype=torch.long)\n",
        "\n",
        "# Load pre-trained BERT tokenizer\n",
        "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n",
        "\n",
        "# Create DataLoaders\n",
        "train_dataset = SentimentDataset(X_train, y_train, tokenizer)\n",
        "val_dataset = SentimentDataset(X_val, y_val, tokenizer)\n",
        "test_dataset = SentimentDataset(X_test, y_test, tokenizer)\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True)\n",
        "val_loader = DataLoader(val_dataset, batch_size=8, shuffle=False)\n",
        "test_loader = DataLoader(test_dataset, batch_size=8, shuffle=False)"
      ],
      "metadata": {
        "id": "HD_ue6QQ4z-1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 4. Define BERT-based model\n",
        "model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)  # Binary classification\n",
        "model = model.to(device)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pRpoyVeV44H9",
        "outputId": "789852a6-dd92-416b-f2d7-379c43c119be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 5. Define loss function and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.AdamW(model.parameters(), lr=2e-5)"
      ],
      "metadata": {
        "id": "4GZKB5IL47gX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 6. Training loop\n",
        "epochs = 3  # For demonstration purposes\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "\n",
        "for epoch in range(epochs):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    for batch_idx, (input_ids, attention_mask, labels) in enumerate(train_loader):\n",
        "        input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)\n",
        "        loss = outputs.loss\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item()\n",
        "\n",
        "    train_loss = running_loss / len(train_loader)\n",
        "    train_losses.append(train_loss)\n",
        "    print(f\"Epoch [{epoch+1}/{epochs}], Training Loss: {train_loss:.4f}\")\n",
        "\n",
        "    # Validation\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    predictions = []\n",
        "    true_labels = []\n",
        "    with torch.no_grad():\n",
        "        for input_ids, attention_mask, labels in val_loader:\n",
        "            input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "            outputs = model(input_ids, attention_mask=attention_mask, labels=labels)\n",
        "            loss = outputs.loss\n",
        "            val_loss += loss.item()\n",
        "            logits = outputs.logits\n",
        "            preds = torch.argmax(logits, axis=1)\n",
        "            predictions.extend(preds.cpu().numpy())\n",
        "            true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "    val_loss = val_loss / len(val_loader)\n",
        "    val_losses.append(val_loss)\n",
        "    accuracy = accuracy_score(true_labels, predictions)\n",
        "    print(f\"Validation Loss: {val_loss:.4f}, Validation Accuracy: {accuracy:.4f}\")\n",
        "\n",
        "# Plot training and validation loss\n",
        "plt.plot(train_losses, label='Training Loss')\n",
        "plt.plot(val_losses, label='Validation Loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.legend()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QQg6eMXk5FUS",
        "outputId": "2502b84b-4d28-4da1-f4a6-614c32dab14b"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "this approach takes much time\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 7. Save and load the model\n",
        "torch.save(model.state_dict(), 'bert_sentiment_model.pth')  # Save model\n",
        "print(\"Model saved!\")\n",
        "\n",
        "# Load the model\n",
        "loaded_model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)\n",
        "loaded_model.load_state_dict(torch.load('bert_sentiment_model.pth'))\n",
        "loaded_model.to(device)\n",
        "loaded_model.eval()"
      ],
      "metadata": {
        "id": "uUhybUXj5JMq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 8. Evaluate the model on the test set\n",
        "predictions = []\n",
        "true_labels = []\n",
        "\n",
        "model.eval()  # Set the model to evaluation mode\n",
        "with torch.no_grad():\n",
        "    for input_ids, attention_mask, labels in test_loader:\n",
        "        input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "        outputs = model(input_ids, attention_mask=attention_mask)\n",
        "        logits = outputs.logits\n",
        "        preds = torch.argmax(logits, axis=1)\n",
        "        predictions.extend(preds.cpu().numpy())\n",
        "        true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "accuracy = accuracy_score(true_labels, predictions)\n",
        "print(f\"Test Accuracy: {accuracy:.4f}\")\n",
        "\n",
        "# Print the classification report\n",
        "print(\"\\nClassification Report:\\n\")\n",
        "print(classification_report(true_labels, predictions))"
      ],
      "metadata": {
        "id": "V7f6LI_Q5L-h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "BERT with PEFT"
      ],
      "metadata": {
        "id": "D4XGd0oV7YBV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, Dataset\n",
        "from transformers import BertTokenizer, BertForSequenceClassification\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score, classification_report\n",
        "import numpy as np\n",
        "from datasets import load_dataset\n",
        "import matplotlib.pyplot as plt\n",
        "from peft import LoraConfig, get_peft_model\n",
        "\n",
        "# 1. Check if GPU is available and set device\n",
        "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": "WPBo-rFz7awS",
        "outputId": "20270fca-b28d-42ee-dab3-0768384ab01a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device: cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from datasets import load_dataset\n",
        "from torch.utils.data import random_split\n",
        "\n",
        "# Load dataset\n",
        "dataset = load_dataset(\"imdb\")\n",
        "\n",
        "# Sample 10% from train and split test into 80% for test, 20% for validation\n",
        "train_data = list(zip(dataset['train']['text'], dataset['train']['label']))\n",
        "train_data_sampled = np.random.choice(len(train_data), size=int(len(train_data) * 0.1), replace=False)\n",
        "train_data_sampled = [train_data[i] for i in train_data_sampled]\n",
        "\n",
        "test_data = list(zip(dataset['test']['text'], dataset['test']['label']))\n",
        "val_size = int(len(test_data) * 0.2)\n",
        "test_data, val_data = random_split(test_data, [len(test_data) - val_size, val_size])\n",
        "\n",
        "# Unzip data into features and labels\n",
        "X_train, y_train = zip(*train_data_sampled)\n",
        "X_test, y_test = zip(*test_data)\n",
        "X_val, y_val = zip(*val_data)\n",
        "\n",
        "# Print lengths\n",
        "print(len(X_train), len(X_test), len(X_val))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-pltNZJfGn9u",
        "outputId": "bfb468c5-e435-48cf-cf8a-226ad7736d78"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2500 20000 5000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dataset"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j_Y-YoXXFRCy",
        "outputId": "0acb1356-4f29-4bd5-ab96-e93cead19077"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "DatasetDict({\n",
              "    train: Dataset({\n",
              "        features: ['text', 'label'],\n",
              "        num_rows: 25000\n",
              "    })\n",
              "    test: Dataset({\n",
              "        features: ['text', 'label'],\n",
              "        num_rows: 25000\n",
              "    })\n",
              "    unsupervised: Dataset({\n",
              "        features: ['text', 'label'],\n",
              "        num_rows: 50000\n",
              "    })\n",
              "})"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import Counter\n",
        "Counter(load_dataset(\"imdb\", split='train')['label'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "naGmGPEpDtyO",
        "outputId": "42cb781e-e1e1-4552-aafc-e0a978416e6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Counter({0: 12500, 1: 12500})"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import Counter\n",
        "print(Counter(y_train))\n",
        "print(Counter(y_val))\n",
        "print(Counter(y_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jWZQoUOUDfDv",
        "outputId": "dd3ba592-0c81-46d9-db55-5d2153d67b67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Counter({1: 1266, 0: 1234})\n",
            "Counter({1: 2504, 0: 2496})\n",
            "Counter({0: 10004, 1: 9996})\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3. Tokenization and Data Preparation\n",
        "class SentimentDataset(Dataset):\n",
        "    def __init__(self, texts, labels, tokenizer, max_len=128):\n",
        "        self.texts = texts\n",
        "        self.labels = labels\n",
        "        self.tokenizer = tokenizer\n",
        "        self.max_len = max_len\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.texts)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        text = self.texts[idx]\n",
        "        label = self.labels[idx]\n",
        "        encoding = self.tokenizer(\n",
        "            text,\n",
        "            max_length=self.max_len,\n",
        "            padding='max_length',\n",
        "            truncation=True,\n",
        "            return_tensors=\"pt\"\n",
        "        )\n",
        "        input_ids = encoding['input_ids'].squeeze(0)  # Remove batch dimension\n",
        "        attention_mask = encoding['attention_mask'].squeeze(0)  # Remove batch dimension\n",
        "        return input_ids, attention_mask, torch.tensor(label, dtype=torch.long)\n",
        "\n",
        "# Load pre-trained BERT tokenizer\n",
        "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n",
        "\n",
        "# Create DataLoaders\n",
        "train_dataset = SentimentDataset(X_train, y_train, tokenizer)\n",
        "val_dataset = SentimentDataset(X_val, y_val, tokenizer)\n",
        "test_dataset = SentimentDataset(X_test, y_test, tokenizer)\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
        "val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)\n",
        "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)\n",
        "\n",
        "# 4. Define BERT-based model with PEFT LoRA\n",
        "lora_config = LoraConfig(\n",
        "    r=8, lora_alpha=32, lora_dropout=0.1, task_type=\"SEQ_CLS\"\n",
        ")\n",
        "\n",
        "base_model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)  # Binary classification\n",
        "model = get_peft_model(base_model, lora_config)\n",
        "model = model.to(device)\n",
        "\n",
        "# 5. Define loss function and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.AdamW(model.parameters(), lr=2e-5)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QoLumBpj7hjC",
        "outputId": "a7a29e70-72f8-4998-df8e-f95f46bec455"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 6. Training loop\n",
        "epochs = 3  # For demonstration purposes\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "\n",
        "for epoch in range(epochs):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    for batch_idx, (input_ids, attention_mask, labels) in enumerate(train_loader):\n",
        "        input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)\n",
        "        loss = outputs.loss\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item()\n",
        "\n",
        "    train_loss = running_loss / len(train_loader)\n",
        "    train_losses.append(train_loss)\n",
        "    print(f\"Epoch [{epoch+1}/{epochs}], Training Loss: {train_loss:.4f}\")\n",
        "\n",
        "    # Validation\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    predictions = []\n",
        "    true_labels = []\n",
        "    with torch.no_grad():\n",
        "        for input_ids, attention_mask, labels in val_loader:\n",
        "            input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "            outputs = model(input_ids, attention_mask=attention_mask, labels=labels)\n",
        "            loss = outputs.loss\n",
        "            val_loss += loss.item()\n",
        "            logits = outputs.logits\n",
        "            preds = torch.argmax(logits, axis=1)\n",
        "            predictions.extend(preds.cpu().numpy())\n",
        "            true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "    val_loss = val_loss / len(val_loader)\n",
        "    val_losses.append(val_loss)\n",
        "    accuracy = accuracy_score(true_labels, predictions)\n",
        "    print(f\"Validation Loss: {val_loss:.4f}, Validation Accuracy: {accuracy:.4f}\")\n",
        "\n",
        "# Plot training and validation loss\n",
        "plt.plot(train_losses, label='Training Loss')\n",
        "plt.plot(val_losses, label='Validation Loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 576
        },
        "id": "kn_rkvjh7moP",
        "outputId": "5057af2e-e706-4dd6-b3bb-6533c0561918"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/3], Training Loss: 0.7015\n",
            "Validation Loss: 0.6984, Validation Accuracy: 0.4604\n",
            "Epoch [2/3], Training Loss: 0.6982\n",
            "Validation Loss: 0.6945, Validation Accuracy: 0.4912\n",
            "Epoch [3/3], Training Loss: 0.6963\n",
            "Validation Loss: 0.6908, Validation Accuracy: 0.5270\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHHCAYAAACr0swBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACDaUlEQVR4nOzdd1xV9R/H8ddlbxBBlsgS3BOVcFu4M205MleaZY7MLDVTsywrrcyRK9OyTNNcpYkj994jFwgCDlRUprLuPb8/rt5fN3CAwGF8no/HfdT93u8993O4F++b8/2e79EoiqIghBBCCCGMmKhdgBBCCCFEcSQhSQghhBAiFxKShBBCCCFyISFJCCGEECIXEpKEEEIIIXIhIUkIIYQQIhcSkoQQQgghciEhSQghhBAiFxKShBBCCCFyISFJiBKob9+++Pr65uu5H330ERqNpmALKmYuXryIRqNh0aJFRf7aGo2Gjz76yHB/0aJFaDQaLl68+Mjn+vr60rdv3wKt50k+K0KUdRKShChAGo3msW7btm1Tu9Qyb9iwYWg0GiIjIx/YZ+zYsWg0Gk6cOFGEleXdlStX+Oijjzh27JjapRjcD6pTp05VuxQh8s1M7QKEKE0WL15sdP+nn35i06ZNOdqrVav2RK8zf/58dDpdvp774YcfMnr06Cd6/dKgZ8+ezJgxgyVLljB+/Phc+/z666/UqlWL2rVr5/t1evXqRffu3bG0tMz3Nh7lypUrTJw4EV9fX+rWrWv02JN8VoQo6yQkCVGAXn31VaP7+/btY9OmTTna/+vOnTvY2Ng89uuYm5vnqz4AMzMzzMzkVz8kJITKlSvz66+/5hqS9u7dS3R0NJ9//vkTvY6pqSmmpqZPtI0n8SSfFSHKOhluE6KItWzZkpo1a3L48GGaN2+OjY0NH3zwAQBr1qyhY8eOeHp6YmlpSUBAAJ988glardZoG/+dZ/LvoY158+YREBCApaUlDRs25ODBg0bPzW1OkkajYciQIaxevZqaNWtiaWlJjRo12LBhQ476t23bRoMGDbCysiIgIIC5c+c+9jynnTt38vLLL1OpUiUsLS3x9vbmnXfe4e7duzn2z87OjsuXL9OlSxfs7OxwdXVl5MiROX4WiYmJ9O3bF0dHR5ycnOjTpw+JiYmPrAX0R5POnj3LkSNHcjy2ZMkSNBoNPXr0IDMzk/HjxxMcHIyjoyO2trY0a9aMrVu3PvI1cpuTpCgKkyZNomLFitjY2NCqVSv++eefHM+9desWI0eOpFatWtjZ2eHg4ED79u05fvy4oc+2bdto2LAhAP369TMM6d6fj5XbnKS0tDTeffddvL29sbS0pEqVKkydOhVFUYz65eVzkV/Xr1+nf//+uLm5YWVlRZ06dfjxxx9z9Fu6dCnBwcHY29vj4OBArVq1+Pbbbw2PZ2VlMXHiRAIDA7GysqJ8+fI0bdqUTZs2FVitouyRPyeFUMHNmzdp37493bt359VXX8XNzQ3Qf6Ha2dkxYsQI7Ozs+Pvvvxk/fjzJyclMmTLlkdtdsmQJKSkpvPHGG2g0Gr788kteeOEFoqKiHnlEYdeuXaxcuZK33noLe3t7pk+fzosvvkhsbCzly5cH4OjRo7Rr1w4PDw8mTpyIVqvl448/xtXV9bH2e/ny5dy5c4dBgwZRvnx5Dhw4wIwZM7h06RLLly836qvVamnbti0hISFMnTqVzZs389VXXxEQEMCgQYMAfdjo3Lkzu3bt4s0336RatWqsWrWKPn36PFY9PXv2ZOLEiSxZsoT69esbvfZvv/1Gs2bNqFSpEgkJCXz//ff06NGD119/nZSUFBYsWEDbtm05cOBAjiGuRxk/fjyTJk2iQ4cOdOjQgSNHjtCmTRsyMzON+kVFRbF69Wpefvll/Pz8uHbtGnPnzqVFixacPn0aT09PqlWrxscff8z48eMZOHAgzZo1A6Bx48a5vraiKDz33HNs3bqV/v37U7duXcLDw3nvvfe4fPky33zzjVH/x/lc5Nfdu3dp2bIlkZGRDBkyBD8/P5YvX07fvn1JTEzk7bffBmDTpk306NGDZ555hi+++AKAM2fOsHv3bkOfjz76iMmTJzNgwAAaNWpEcnIyhw4d4siRI7Ru3fqJ6hRlmCKEKDSDBw9W/vtr1qJFCwVQ5syZk6P/nTt3crS98cYbio2NjZKenm5o69Onj+Lj42O4Hx0drQBK+fLllVu3bhna16xZowDKH3/8YWibMGFCjpoAxcLCQomMjDS0HT9+XAGUGTNmGNo6deqk2NjYKJcvXza0RUREKGZmZjm2mZvc9m/y5MmKRqNRYmJijPYPUD7++GOjvvXq1VOCg4MN91evXq0Aypdffmloy87OVpo1a6YAysKFCx9ZU8OGDZWKFSsqWq3W0LZhwwYFUObOnWvYZkZGhtHzbt++rbi5uSmvvfaaUTugTJgwwXB/4cKFCqBER0criqIo169fVywsLJSOHTsqOp3O0O+DDz5QAKVPnz6GtvT0dKO6FEX/XltaWhr9bA4ePPjA/f3vZ+X+z2zSpElG/V566SVFo9EYfQYe93ORm/ufySlTpjywz7Rp0xRA+fnnnw1tmZmZSmhoqGJnZ6ckJycriqIob7/9tuLg4KBkZ2c/cFt16tRROnbs+NCahMgrGW4TQgWWlpb069cvR7u1tbXh/1NSUkhISKBZs2bcuXOHs2fPPnK73bp1o1y5cob7948qREVFPfK5YWFhBAQEGO7Xrl0bBwcHw3O1Wi2bN2+mS5cueHp6GvpVrlyZ9u3bP3L7YLx/aWlpJCQk0LhxYxRF4ejRozn6v/nmm0b3mzVrZrQv69evx8zMzHBkCfRzgIYOHfpY9YB+HtmlS5fYsWOHoW3JkiVYWFjw8ssvG7ZpYWEBgE6n49atW2RnZ9OgQYNch+oeZvPmzWRmZjJ06FCjIcrhw4fn6GtpaYmJif6faa1Wy82bN7Gzs6NKlSp5ft371q9fj6mpKcOGDTNqf/fdd1EUhb/++suo/VGfiyexfv163N3d6dGjh6HN3NycYcOGkZqayvbt2wFwcnIiLS3toUNnTk5O/PPPP0RERDxxXULcJyFJCBV4eXkZvnT/7Z9//uH555/H0dERBwcHXF1dDZO+k5KSHrndSpUqGd2/H5hu376d5+fef/79516/fp27d+9SuXLlHP1ya8tNbGwsffv2xdnZ2TDPqEWLFkDO/bOyssoxjPfvegBiYmLw8PDAzs7OqF+VKlUeqx6A7t27Y2pqypIlSwBIT09n1apVtG/f3ihw/vjjj9SuXdsw38XV1ZV169Y91vvybzExMQAEBgYatbu6uhq9HugD2TfffENgYCCWlpa4uLjg6urKiRMn8vy6/359T09P7O3tjdrvn3F5v777HvW5eBIxMTEEBgYaguCDannrrbcICgqiffv2VKxYkddeey3HvKiPP/6YxMREgoKCqFWrFu+9916xX7pBFH8SkoRQwb+PqNyXmJhIixYtOH78OB9//DF//PEHmzZtMszBeJzTuB90FpXynwm5Bf3cx6HVamndujXr1q1j1KhRrF69mk2bNhkmGP93/4rqjLAKFSrQunVrfv/9d7Kysvjjjz9ISUmhZ8+ehj4///wzffv2JSAggAULFrBhwwY2bdrE008/Xain13/22WeMGDGC5s2b8/PPPxMeHs6mTZuoUaNGkZ3WX9ifi8dRoUIFjh07xtq1aw3zqdq3b28096x58+ZcuHCBH374gZo1a/L9999Tv359vv/++yKrU5Q+MnFbiGJi27Zt3Lx5k5UrV9K8eXNDe3R0tIpV/V+FChWwsrLKdfHFhy3IeN/Jkyc5f/48P/74I7179za0P8nZRz4+PmzZsoXU1FSjo0nnzp3L03Z69uzJhg0b+Ouvv1iyZAkODg506tTJ8PiKFSvw9/dn5cqVRkNkEyZMyFfNABEREfj7+xvab9y4kePozIoVK2jVqhULFiwwak9MTMTFxcVwPy8rqPv4+LB582ZSUlKMjibdH869X19R8PHx4cSJE+h0OqOjSbnVYmFhQadOnejUqRM6nY633nqLuXPnMm7cOMORTGdnZ/r160e/fv1ITU2lefPmfPTRRwwYMKDI9kmULnIkSYhi4v5f7P/+Cz0zM5PvvvtOrZKMmJqaEhYWxurVq7ly5YqhPTIyMsc8lgc9H4z3T1EUo9O486pDhw5kZ2cze/ZsQ5tWq2XGjBl52k6XLl2wsbHhu+++46+//uKFF17AysrqobXv37+fvXv35rnmsLAwzM3NmTFjhtH2pk2blqOvqalpjiM2y5cv5/Lly0Zttra2AI+19EGHDh3QarXMnDnTqP2bb75Bo9E89vyygtChQwfi4+NZtmyZoS07O5sZM2ZgZ2dnGIq9efOm0fNMTEwMC3xmZGTk2sfOzo7KlSsbHhciP+RIkhDFROPGjSlXrhx9+vQxXDJj8eLFRTqs8SgfffQRGzdupEmTJgwaNMjwZVuzZs1HXhKjatWqBAQEMHLkSC5fvoyDgwO///77E81t6dSpE02aNGH06NFcvHiR6tWrs3LlyjzP17Gzs6NLly6GeUn/HmoDePbZZ1m5ciXPP/88HTt2JDo6mjlz5lC9enVSU1Pz9Fr313uaPHkyzz77LB06dODo0aP89ddfRkeH7r/uxx9/TL9+/WjcuDEnT57kl19+MToCBRAQEICTkxNz5szB3t4eW1tbQkJC8PPzy/H6nTp1olWrVowdO5aLFy9Sp04dNm7cyJo1axg+fLjRJO2CsGXLFtLT03O0d+nShYEDBzJ37lz69u3L4cOH8fX1ZcWKFezevZtp06YZjnQNGDCAW7du8fTTT1OxYkViYmKYMWMGdevWNcxfql69Oi1btiQ4OBhnZ2cOHTrEihUrGDJkSIHujyhj1DmpToiy4UFLANSoUSPX/rt371aeeuopxdraWvH09FTef/99JTw8XAGUrVu3Gvo9aAmA3E635j+npD9oCYDBgwfneK6Pj4/RKemKoihbtmxR6tWrp1hYWCgBAQHK999/r7z77ruKlZXVA34K/3f69GklLCxMsbOzU1xcXJTXX3/dcEr5v09f79Onj2Jra5vj+bnVfvPmTaVXr16Kg4OD4ujoqPTq1Us5evToYy8BcN+6desUQPHw8Mhx2r1Op1M+++wzxcfHR7G0tFTq1aun/PnnnzneB0V59BIAiqIoWq1WmThxouLh4aFYW1srLVu2VE6dOpXj552enq68++67hn5NmjRR9u7dq7Ro0UJp0aKF0euuWbNGqV69umE5hvv7nluNKSkpyjvvvKN4enoq5ubmSmBgoDJlyhSjJQnu78vjfi7+6/5n8kG3xYsXK4qiKNeuXVP69eunuLi4KBYWFkqtWrVyvG8rVqxQ2rRpo1SoUEGxsLBQKlWqpLzxxhvK1atXDX0mTZqkNGrUSHFyclKsra2VqlWrKp9++qmSmZn50DqFeBiNohSjP1OFECVSly5d5PRrIUSpI3OShBB58t9LiERERLB+/XpatmypTkFCCFFI5EiSECJPPDw86Nu3L/7+/sTExDB79mwyMjI4evRojrV/hBCiJJOJ20KIPGnXrh2//vor8fHxWFpaEhoaymeffSYBSQhR6hSL4bZZs2bh6+uLlZUVISEhHDhw4IF9W7ZsabjK9b9vHTt2NPRRFIXx48fj4eGBtbU1YWFhRnMlLl68SP/+/fHz88Pa2pqAgAAmTJiQ4+KSQoicFi5cyMWLF0lPTycpKYkNGzYYXRxWCCFKC9VD0rJlyxgxYgQTJkzgyJEj1KlTh7Zt23L9+vVc+69cuZKrV68abqdOncLU1NRwjSWAL7/8kunTpzNnzhz279+Pra0tbdu2NZyGevbsWXQ6HXPnzuWff/7hm2++Yc6cOXzwwQdFss9CCCGEKP5Un5MUEhJCw4YNDQub6XQ6vL29GTp0KKNHj37k86dNm8b48eO5evUqtra2KIqCp6cn7777LiNHjgT014Ryc3Nj0aJFdO/ePdftTJkyhdmzZxfIRRuFEEIIUfKpOicpMzOTw4cPM2bMGEObiYkJYWFhj72S7YIFC+jevbthxdno6Gji4+MJCwsz9HF0dCQkJIS9e/c+MCQlJSXh7Oz8wNfJyMgwWrn1/pXAy5cvn6dLAgghhBBCPYqikJKSgqenZ46LK/+XqiEpISEBrVaLm5ubUbubm5vh2j0Pc+DAAU6dOmV0XaP4+HjDNv67zfuP/VdkZCQzZsxg6tSpD3ytyZMnM3HixEfWJIQQQojiLy4ujooVKz60T4k+u23BggXUqlWLRo0a5Xsbly9fpl27drz88su8/vrrD+w3ZswYRowYYbiflJREpUqViIuLw8HBId+vL4QQQoiik5ycjLe3t9EFnh9E1ZDk4uKCqakp165dM2q/du0a7u7uD31uWloaS5cu5eOPPzZqv/+8a9eu4eHhYbTNunXrGvW9cuUKrVq1onHjxsybN++hr2dpaYmlpWWOdgcHBwlJQgghRAnzOFNlVD27zcLCguDgYLZs2WJo0+l0bNmyhdDQ0Ic+d/ny5WRkZPDqq68atfv5+eHu7m60zeTkZPbv32+0zcuXLxsuhrhw4cJHjksKIYQQomxRfbhtxIgR9OnThwYNGtCoUSOmTZtGWloa/fr1A6B37954eXkxefJko+ctWLCALl26UL58eaN2jUbD8OHDmTRpEoGBgfj5+TFu3Dg8PT3p0qUL8P+A5OPjw9SpU7lx44bh+Y86giWEEEKIskH1kNStWzdu3LjB+PHjiY+Pp27dumzYsMEw8To2NjbHUZ5z586xa9cuNm7cmOs233//fdLS0hg4cCCJiYk0bdqUDRs2YGVlBcCmTZuIjIwkMjIyx6QtuUqLEEIIIaAYrJNUUiUnJ+Po6EhSUpLMSRJCiHzQ6XRypQNR4MzNzTE1NX3g43n5/lb9SJIQQoiyJzMzk+joaHQ6ndqliFLIyckJd3f3J17HUEKSEEKIIqUoClevXsXU1BRvb285cUYUGEVRuHPnjuHSZv8+yz0/JCQJIYQoUtnZ2dy5cwdPT09sbGzULkeUMtbW1gBcv36dChUqPHTo7VEkvgshhChSWq0W0C8DI0RhuB++s7Kynmg7EpKEEEKoQq57KQpLQX22JCQJIYQQQuRCQpIQQgihEl9fX6ZNm/bY/bdt24ZGoyExMbHQahL/JyFJCCGEeASNRvPQ20cffZSv7R48eJCBAwc+dv/GjRtz9epVHB0d8/V6j0vCmJ6c3VbMZGRrORxzm1D/8jJeL4QQxcTVq1cN/79s2TLGjx/PuXPnDG12dnaG/1cUBa1Wi5nZo79iXV1d81SHhYWFXD6rCMmRpGJmzbErvDJ/P51m7mLNsctka2WhNSGEUJu7u7vh5ujoiEajMdw/e/Ys9vb2/PXXXwQHB2NpacmuXbu4cOECnTt3xs3NDTs7Oxo2bMjmzZuNtvvf4TaNRsP333/P888/j42NDYGBgaxdu9bw+H+P8CxatAgnJyfCw8OpVq0adnZ2tGvXzijUZWdnM2zYMJycnChfvjyjRo2iT58+huuZ5sft27fp3bs35cqVw8bGhvbt2xMREWF4PCYmhk6dOlGuXDlsbW2pUaMG69evNzy3Z8+euLq6Ym1tTWBgIAsXLsx3LYVJQlIxczstEytzE05dTubtpcdoMWUbP+yKJi0jW+3ShBCiUCiKwp3MbFVuBXllrtGjR/P5559z5swZateuTWpqKh06dGDLli0cPXqUdu3a0alTJ2JjYx+6nYkTJ9K1a1dOnDhBhw4d6NmzJ7du3Xpg/zt37jB16lQWL17Mjh07iI2NZeTIkYbHv/jiC3755RcWLlzI7t27SU5OZvXq1U+0r3379uXQoUOsXbuWvXv3oigKHTp0MJxyP3jwYDIyMtixYwcnT57kiy++MBxtGzduHKdPn+avv/7izJkzzJ49GxcXlyeqp7DIcFsx80aLALo28Gbxvhh+3HORy4l3+fjP00zbfJ5Xn/Khb2NfKjhYqV2mEEIUmLtZWqqPD1fltU9/3BYbi4L5Kvz4449p3bq14b6zszN16tQx3P/kk09YtWoVa9euZciQIQ/cTt++fenRowcAn332GdOnT+fAgQO0a9cu1/5ZWVnMmTOHgIAAAIYMGcLHH39seHzGjBmMGTOG559/HoCZM2cajurkR0REBGvXrmX37t00btwYgF9++QVvb29Wr17Nyy+/TGxsLC+++CK1atUCwN/f3/D82NhY6tWrR4MGDQD90bTiSo4kFUPlbC0Y9kwgu0c/zWfP18LfxZbk9Gy+23aBpl9s5f0Vx4m4lqJ2mUIIIf7l/pf+fampqYwcOZJq1arh5OSEnZ0dZ86ceeSRpNq1axv+39bWFgcHB8NlNnJjY2NjCEigvxTH/f5JSUlcu3aNRo0aGR43NTUlODg4T/v2b2fOnMHMzIyQkBBDW/ny5alSpQpnzpwBYNiwYUyaNIkmTZowYcIETpw4Yeg7aNAgli5dSt26dXn//ffZs2dPvmspbHIkqRizMjfllZBKdG/ozaYz15i/I4pDMbf57dAlfjt0iaerVmBgc39C/JxlkrcQosSyNjfl9MdtVXvtgmJra2t0f+TIkWzatImpU6dSuXJlrK2teemll8jMzHzodszNzY3uazSah14IOLf+BTmMmB8DBgygbdu2rFu3jo0bNzJ58mS++uorhg4dSvv27YmJiWH9+vVs2rSJZ555hsGDBzN16lRVa86NHEkqAUxMNLSt4c6KQY35fVBj2tVwR6OBv89ep/u8fXSZtZs/T1yRSd5CiBJJo9FgY2Gmyq0w/8DcvXs3ffv25fnnn6dWrVq4u7tz8eLFQnu93Dg6OuLm5sbBgwcNbVqtliNHjuR7m9WqVSM7O5v9+/cb2m7evMm5c+eoXr26oc3b25s333yTlStX8u677zJ//nzDY66urvTp04eff/6ZadOmMW/evHzXU5jkSFIJE+xTjuBewUQnpPH9zihWHL7E8UtJDFlyFG9na/o38aNrQ+8CG2MXQgiRP4GBgaxcuZJOnTqh0WgYN27cQ48IFZahQ4cyefJkKleuTNWqVZkxYwa3b99+rIB48uRJ7O3tDfc1Gg116tShc+fOvP7668ydOxd7e3tGjx6Nl5cXnTt3BmD48OG0b9+eoKAgbt++zdatW6lWrRoA48ePJzg4mBo1apCRkcGff/5peKy4kW/SEsrPxZZPn6/FiNZB/LQ3hp/2XiTu1l0++uM007ZE0OspH3qH+uJqb6l2qUIIUSZ9/fXXvPbaazRu3BgXFxdGjRpFcnJykdcxatQo4uPj6d27N6ampgwcOJC2bdtiavroocbmzZsb3Tc1NSU7O5uFCxfy9ttv8+yzz5KZmUnz5s1Zv369YehPq9UyePBgLl26hIODA+3ateObb74B9Gs9jRkzhosXL2JtbU2zZs1YunRpwe94AdAoag9cllDJyck4OjqSlJSEg4OD2uVwN1PLiiOX+H5nFDE37wBgYWbCi/W9GNDMnwBXu0dsQQghikZ6ejrR0dH4+flhZSVn6xY1nU5HtWrV6Nq1K5988ona5RSKh33G8vL9LUeSSglrC1N6PeXDK40qsel0PHN3RHE0NpFfD8Tx64E4wqq58UYLfxr4lJNJ3kIIUYbExMSwceNGWrRoQUZGBjNnziQ6OppXXnlF7dKKPQlJpYypiYZ2NT1oW8OdQzG3mbs9is1nrhlu9So5MbCZP21quGNqImFJCCFKOxMTExYtWsTIkSNRFIWaNWuyefPmYjsPqDiRkFRKaTQaGvo609DXmQs3Uvl+ZxS/H7nM0dhEBv1yBJ/yNgxo6sdLwd5YWxTcKbBCCCGKF29vb3bv3q12GSWSLAFQBgS42jH5hdrsHvU0Q5+ujJONOTE37zBuzT80+eJvvtl0npupGWqXKYQQQhQrEpLKEFd7S95tU4U9o59m4nM18Ha25lZaJt9uiaDx538zdtVJohPS1C5TCCGEKBYkJJVBNhZm9Gnsy9Z3WzLrlfrUqehIRraOX/bH8vRX23hj8SEOx9xWu0whhBBCVTInqQwzMzWhY20POtRyZ3/0LebviGLL2euE/3ON8H+u0cCnHK8396d1NTdMZJK3EEKIMkZCkkCj0fCUf3me8i9PxLUU5u+MYvXRKxyKuc2hxYfxd7FlQDN/XqjvhVUBXudICCGEKM5kuE0YCXSz58uX6rBrVCveahmAg5UZUQlpfLDqJE0+/5vpWyK4nfbwizMKIYQQpYGEJJGrCg5WvN+uKnvHPMP4Z6vj5WTNzbRMvt50ntDPtzB+zSli763sLYQQ4vG0bNmS4cOHG+77+voybdq0hz5Ho9GwevXqJ37tgtpOWSIhSTyUraUZrzX1Y/t7Lfm2e11qeDqQnqXjp70xtJy6lbd+OcyxuES1yxRCiELVqVMn2rVrl+tjO3fuRKPRcOLEiTxv9+DBgwwcOPBJyzPy0UcfUbdu3RztV69epX379gX6Wv+1aNEinJycCvU1ipLMSRKPxczUhM51vXiujid7L9xk3s4otp27wfqT8aw/GU8jP2cGNvPn6aoVZJK3EKLU6d+/Py+++CKXLl2iYsWKRo8tXLiQBg0aULt27Txv19XVtaBKfCR3d/cie63SQo4kiTzRaDQ0ruzCon6NCB/enBfrV8TcVMOB6FsM+OkQrb/ZztIDsaRnadUuVQghCsyzzz6Lq6srixYtMmpPTU1l+fLl9O/fn5s3b9KjRw+8vLywsbGhVq1a/Prrrw/d7n+H2yIiImjevDlWVlZUr16dTZs25XjOqFGjCAoKwsbGBn9/f8aNG0dWVhagP5IzceJEjh8/jkajQaPRGGr+73DbyZMnefrpp7G2tqZ8+fIMHDiQ1NRUw+N9+/alS5cuTJ06FQ8PD8qXL8/gwYMNr5UfsbGxdO7cGTs7OxwcHOjatSvXrl0zPH78+HFatWqFvb09Dg4OBAcHc+jQIUB/DbpOnTpRrlw5bG1tqVGjBuvXr893LY9DjiSJfKvibs9XXevwXtsqLNwTzZJ9sVy4kcbolSeZuvE8/Zr48mqID4425mqXKoQozhQFslSa42huA49x0W8zMzN69+7NokWLGDt2rOFC4cuXL0er1dKjRw9SU1MJDg5m1KhRODg4sG7dOnr16kVAQACNGjV65GvodDpeeOEF3Nzc2L9/P0lJSUbzl+6zt7dn0aJFeHp6cvLkSV5//XXs7e15//336datG6dOnWLDhg1s3rwZAEdHxxzbSEtLo23btoSGhnLw4EGuX7/OgAEDGDJkiFEQ3Lp1Kx4eHmzdupXIyEi6detG3bp1ef311x+5P7nt3/2AtH37drKzsxk8eDDdunVj27ZtAPTs2ZN69eoxe/ZsTE1NOXbsGObm+u+QwYMHk5mZyY4dO7C1teX06dPY2dnluY68kJAknpi7oxVj2ldjSKvKLDsYxw+7ormSlM6U8HPM2hpJ1wbe9G/qh7ezjdqlCiGKo6w78JmnOq/9wRWwsH2srq+99hpTpkxh+/bttGzZEtAPtb344os4Ojri6OjIyJEjDf2HDh1KeHg4v/3222OFpM2bN3P27FnCw8Px9NT/PD777LMc84g+/PBDw//7+voycuRIli5dyvvvv4+1tTV2dnaYmZk9dHhtyZIlpKen89NPP2Frq9//mTNn0qlTJ7744gvc3NwAKFeuHDNnzsTU1JSqVavSsWNHtmzZkq+QtGXLFk6ePEl0dDTe3t4A/PTTT9SoUYODBw/SsGFDYmNjee+996hatSoAgYGBhufHxsby4osvUqtWLQD8/f3zXENeyXCbKDD2VuYMaObP9vdbMa1bXap5OHAnU8uiPRdpMWUrQ5Yc4eSlJLXLFEKIfKlatSqNGzfmhx9+ACAyMpKdO3fSv39/ALRaLZ988gm1atXC2dkZOzs7wsPDiY2NfaztnzlzBm9vb0NAAggNDc3Rb9myZTRp0gR3d3fs7Oz48MMPH/s1/v1aderUMQQkgCZNmqDT6Th37pyhrUaNGpia/n99PA8PD65fv56n1/r3a3p7exsCEkD16tVxcnLizJkzAIwYMYIBAwYQFhbG559/zoULFwx9hw0bxqRJk2jSpAkTJkzI10T5vJIjSaLAmZua0KWeF53rerIrMoF5O6LYGZHAnyeu8ueJq4T6l2dgc39aVnE1HLIWQpRh5jb6IzpqvXYe9O/fn6FDhzJr1iwWLlxIQEAALVq0AGDKlCl8++23TJs2jVq1amFra8vw4cPJzCy4teX27t1Lz549mThxIm3btsXR0ZGlS5fy1VdfFdhr/Nv9oa77NBoNOp2uUF4L9GfmvfLKK6xbt46//vqLCRMmsHTpUp5//nkGDBhA27ZtWbduHRs3bmTy5Ml89dVXDB06tNDqkSNJotBoNBqaBbqyuH8I64c14/l6XpiZaNgbdZN+iw7SdtoOlh+KIyNbJnkLUaZpNPohLzVuefxDrWvXrpiYmLBkyRJ++uknXnvtNcMfe7t376Zz5868+uqr1KlTB39/f86fP//Y265WrRpxcXFcvXrV0LZv3z6jPnv27MHHx4exY8fSoEEDAgMDiYmJMepjYWGBVvvwf1erVavG8ePHSUv7/0XNd+/ejYmJCVWqVHnsmvPi/v7FxcUZ2k6fPk1iYiLVq1c3tAUFBfHOO++wceNGXnjhBRYuXGh4zNvbmzfffJOVK1fy7rvvMn/+/EKp9T4JSaJIVPd04Jtuddnxfiteb+aHnaUZ56+l8t6KEzT7Yiuzt10g6W7+z5gQQoiiYGdnR7du3RgzZgxXr16lb9++hscCAwPZtGkTe/bs4cyZM7zxxhtGZ249SlhYGEFBQfTp04fjx4+zc+dOxo4da9QnMDCQ2NhYli5dyoULF5g+fTqrVq0y6uPr60t0dDTHjh0jISGBjIyMHK/Vs2dPrKys6NOnD6dOnWLr1q0MHTqUXr16GeYj5ZdWq+XYsWNGtzNnzhAWFkatWrXo2bMnR44c4cCBA/Tu3ZsWLVrQoEED7t69y5AhQ9i2bRsxMTHs3r2bgwcPUq1aNQCGDx9OeHg40dHRHDlyhK1btxoeKywSkkSR8nSyZmzH6uwZ8zRj2lfFzcGS6ykZfLHhLI0nb+GTP09zOfGu2mUKIcQD9e/fn9u3b9O2bVuj+UMffvgh9evXp23btrRs2RJ3d3e6dOny2Ns1MTFh1apV3L17l0aNGjFgwAA+/fRToz7PPfcc77zzDkOGDKFu3brs2bOHcePGGfV58cUXadeuHa1atcLV1TXXZQhsbGwIDw/n1q1bNGzYkJdeeolnnnmGmTNn5u2HkYvU1FTq1atndOvUqRMajYY1a9ZQrlw5mjdvTlhYGP7+/ixbtgwAU1NTbt68Se/evQkKCqJr1660b9+eiRMnAvrwNXjwYKpVq0a7du0ICgriu+++e+J6H0ajKIpSqK9QSiUnJ+Po6EhSUhIODg5ql1NiZWbrWHv8CvN3RHHuWgoApiYanq3twevN/KnplfPUVSFEyZaenk50dDR+fn5YWVmpXY4ohR72GcvL97dM3BaqsjAz4aXgirxY34vt528wf2cUuyNvsubYFdYcu0KTyuUZ2DyA5oEuMslbCCFEkZKQJIoFjUZDyyoVaFmlAqcuJzFvRxTrTl5ld+RNdkfepKq7PQOb+/NsbU8szGSUWAghROGTbxtR7NT0cmR6j3psf68lrzXxw8bClLPxKYz47TjNv9zKvB0XSEmXSd5CCCEKl4QkUWxVLGfD+E7V2Tv6Gd5vVwVXe0vik9P5bP1ZGk/+m8/Wn+FqkkzyFkIIUTgkJIliz9HGnLdaVmbXqFZ8+VJtAivYkZKRzbwdUTT7Yisjlh3jzNVktcsUQuSRnDckCktBfbZkTpIoMSzNTOnawJuX6ldk2/nrzN0exf7oW6w8epmVRy/TPMiVgc38aVK5vEzyFqIYu3+Zi8zMTKytrVWuRpRGd+7oL5j83xXD80qWAMgnWQKgeDgel8i8nVH8dfIqunuf5OoeDgxs7k/H2h6Ym8rBUiGKG0VRiI2NJSsrC09PT0xM5PdUFAxFUbhz5w7Xr1/HyckJDw+PHH3y8v0tISmfJCQVL3G37rBgVzTLDsZxN0u/HL+XkzX9mvjSvVEl7CzloKkQxUlmZibR0dGFeh0wUXY5OTnh7u6e66iChKQiICGpeLqdlskv+2NYtOciCan6i0raW5nRM8SHfk18cXOQheuEKC50Ol2BXvxVCNAPsd0f0s2NhKQiICGpeEvP0rL66GXm7Ywi6ob+Ao7mphq61PXi9eb+BLnZq1yhEEIINUhIKgISkkoGnU5hy9nrzN8RxYGLtwztraq48npzf0L9ZZK3EEKUJRKSioCEpJLnaOxt5u2IYsM/8dz/1NfycmRgc3/a13THTCZ5CyFEqSchqQhISCq5Ym6m8f3OaJYfjiM9Sz9ptGI5a/o39aNrA29sZZK3EEKUWnn5/i4WfzrPmjULX19frKysCAkJ4cCBAw/s27JlSzQaTY5bx44dDX0URWH8+PF4eHhgbW1NWFgYERERRtu5desWPXv2xMHBAScnJ/r3709qamqh7aMoPnzK2/JJl5rsGf0M74QF4WxrwaXbd5n4x2kaf/43U8LPcj0lXe0yhRBCqEz1kLRs2TJGjBjBhAkTOHLkCHXq1KFt27Zcv3491/4rV67k6tWrhtupU6cwNTXl5ZdfNvT58ssvmT59OnPmzGH//v3Y2trStm1b0tP//8XXs2dP/vnnHzZt2sSff/7Jjh07GDhwYKHvryg+nG0teDsskD2jn2ZSl5r4lrch6W4Ws7ZeoOnnWxm14gSR11PULlMIIYRKVB9uCwkJoWHDhsycORPQnxLq7e3N0KFDGT169COfP23aNMaPH8/Vq1extbVFURQ8PT159913GTlyJABJSUm4ubmxaNEiunfvzpkzZ6hevToHDx6kQYMGAGzYsIEOHTpw6dIlPD09H/m6MtxW+mh1CptOX2PejgsciU00tIdVq8Drzfxp5Ocsk7yFEKKEKzHDbZmZmRw+fJiwsDBDm4mJCWFhYezdu/extrFgwQK6d++Ora0tANHR0cTHxxtt09HRkZCQEMM29+7di5OTkyEgAYSFhWFiYsL+/ftzfZ2MjAySk5ONbqJ0MTXR0K6mOyvfasLvg0JpU90NjQY2n7lOt3n76PLdHtafvIpWJ9P4hBCiLFA1JCUkJKDVanFzczNqd3NzIz4+/pHPP3DgAKdOnWLAgAGGtvvPe9g24+PjqVChgtHjZmZmODs7P/B1J0+ejKOjo+Hm7e396B0UJVawjzPzejdgy4gWvBJSCQszE47HJfLWL0doNXUbP+29yN1MrdplCiGEKESqz0l6EgsWLKBWrVo0atSo0F9rzJgxJCUlGW5xcXGF/ppCff6udnz2fC32jH6aYc8EUs7GnNhbdxi/5h8af76FrzeeIyE1Q+0yhRBCFAJVQ5KLiwumpqZcu3bNqP3atWu4u7s/9LlpaWksXbqU/v37G7Xff97Dtunu7p5jYnh2dja3bt164OtaWlri4OBgdBNlh4udJSNaB7Fn9DN80rkGlZxtuH0ni+l/R9Lk87/5YNVJom7I2ZFCCFGaqBqSLCwsCA4OZsuWLYY2nU7Hli1bCA0Nfehzly9fTkZGBq+++qpRu5+fH+7u7kbbTE5OZv/+/YZthoaGkpiYyOHDhw19/v77b3Q6HSEhIQWxa6KUsrYwpVeoL1tHtuS7nvWp4+1ERraOJftjeebr7Qz86RCH/rWytxBCiJJL9bPbli1bRp8+fZg7dy6NGjVi2rRp/Pbbb5w9exY3Nzd69+6Nl5cXkydPNnpes2bN8PLyYunSpTm2+cUXX/D555/z448/4ufnx7hx4zhx4gSnT5/Gykp/gdP27dtz7do15syZQ1ZWFv369aNBgwYsWbLkseqWs9sE6NfkOnjxNvN2XGDzmf8fnaxfyYmBzQNoXd0NUxM5I04IIYqLvHx/q760cLdu3bhx4wbjx48nPj6eunXrsmHDBsPE69jYWExMjA94nTt3jl27drFx48Zct/n++++TlpbGwIEDSUxMpGnTpmzYsMEQkAB++eUXhgwZwjPPPIOJiQkvvvgi06dPL7wdFaWSRqOhkZ8zjfycibyewvc7o1l55DJHYhN58+fD+LnY0r+pHy8FV8TK/MFXpRZCCFH8qH4kqaSSI0niQa6npPPTnhgW74sh6W4WoF+4sneoD71DfXG2tVC5QiGEKLvk2m1FQEKSeJS0jGx+OxTHgl3RXLp9FwArcxNeCq7IgKb++LrYqlyhEEKUPRKSioCEJPG4srU6/joVz7wdUZy8nASARgPtargzsLk/9SqVU7lCIYQoOyQkFQEJSSKvFEVhX9Qt5u24wNZzNwztDX3LMbB5AM9UrYCJTPIWQohCJSGpCEhIEk/i/LUU5u+IYvWxy2Rp9b+C/q62vN7Mn+freckkbyGEKCQSkoqAhCRREK4lp7Noz0V+3hdDSno2AC52FvQJ9eXVp3woJ5O8hRCiQElIKgISkkRBSs3IZumBWH7YFc2VpHQArM1N6dqgIgOa+ePtbKNyhUIIUTpISCoCEpJEYcjS6lh/8ipzt0dx+moyACYaaF/Lg4HN/Knj7aRugUIIUcJJSCoCEpJEYVIUhT0XbjJ3RxQ7zv9/kneInzMDm/vTqopM8hZCiPyQkFQEJCSJonLmajLzd0ax9tgVsnX6X9fKFewY2MyfzvU8sTSTSd5CCPG4JCQVAQlJoqhdTbrLot0XWbI/lpQM/SRvV3tL+jb25dUQHxxtzFWuUAghij8JSUVAQpJQS3J61r1J3heJT9ZP8raxMKV7w0q81tSXiuVkkrcQQjyIhKQiICFJqC0zW8efJ64wb0cUZ+NTADA10dCxlgcDm/tT08tR5QqFEKL4kZBUBCQkieJCURR2RiQwb0cUuyITDO2NA8ozsLk/LYJc0WhkkrcQQoCEpCIhIUkUR/9cSWL+jij+OHEV7b1J3lXc7Hm9uT/P1fHEwsxE5QqFEEJdEpKKgIQkUZxdTrzLwl3R/HoglrRMLQBuDpb0a+LHKyGVcLCSSd5CiLJJQlIRkJAkSoKku1ks2R/Lwt3RXE/JAMDO0ozuDb15rakfnk7WKlcohBBFS0JSEZCQJEqSzGwda45dZv7OKM5fSwXAzERDpzqevN7Mn+qe8hkWQpQNEpKKgIQkURIpisK28zeYtz2KvVE3De3NAl0Y2NyfppVdZJK3EKJUk5BUBCQkiZLu5KUk5u2MYv3J/0/yrubhwMDmfjxb2xNzU5nkLYQofSQkFQEJSaK0iLt1hx92R7PsYBx37k3y9nC04rUmfnRv5I29TPIWQpQiEpKKgIQkUdok3snkl/2xLNpzkRv3JnnbW5rxylOV6NfYD3dHK5UrFEKIJychqQhISBKlVUa2ltVHLzNvRxQXbqQBYG6q4bk6Xrze3I+q7vJ5F0KUXBKSioCEJFHa6XQKW89dZ+6OKA5E3zK0twhy5Y3m/oQGlJdJ3kKIEkdCUhGQkCTKkmNxiczfEcVfp65yb443Nb0ceL2ZPx1reWAmk7yFECWEhKQiICFJlEUxN9P4YVc0yw7FkZ6lA8DLyZrXmvrRvaE3tpZmKlcohBAPJyGpCEhIEmXZ7bRMFu+L4cc9F7mZlgmAg5UZrz7lQ9/GvlRwkEneQojiSUJSEZCQJASkZ2lZeeQy3++MIipBP8nbwtSELvX0K3kHutmrXKEQQhiTkFQEJCQJ8X86ncLmM9eYtyOKQzG3De1PV63AwOb+hPg5yyRvIUSxICGpCEhIEiJ3h2NuM39HFOGn47n/r0udio683tyfdjXcZZK3EEJVEpKKgIQkIR4uOiGNBbuiWH7oEhnZ+kne3s7W9G/iR9eG3thYyCRvIUTRk5BUBCQkCfF4bqZm8NPeGH7ae5Hbd7IAcLQ2p9dTPvRp7IurvaXKFQohyhIJSUVAQpIQeXM3U8uKI5f4fmcUMTfvAGBhZsKL9b3o39SfyhXsVK5QCFEWSEgqAhKShMgfrU5h0+l45u6I4mhsoqE9rJobb7Twp4FPOZnkLYQoNBKSioCEJCGejKIoHI65zdwdUWw+c80wybteJScGNvOnTQ13TE0kLAkhCpaEpCIgIUmIgnPhRirf74zm9yOXyLw3ydunvA0DmvrxUrA31hamKlcohCgtJCQVAQlJQhS8GykZ/LT3Iov3xZB4b5K3s60FvZ7yoXeoD+XtZJK3EOLJSEgqAhKShCg8dzKzWX7oEt/viiLu1l0ALM1MeCm4IgOa+ePnYqtyhUKIkkpCUhGQkCRE4dPqFDacimfejgscv5QEgEYDbaq7MbB5AME+5VSuUAhR0khIKgISkoQoOoqicCD6FvN2RLHl7HVDe7BPOQY296d1NTdMZJK3EOIxSEgqAhKShFBHxLUU5u+MYvXRK2Rq9ZO8/VxsGdDMjxfrV8TKXCZ5CyEeTEJSEZCQJIS6riens2jPRX7eF0NyejYA5W0t6NPYl15P+VDO1kLlCoUQxZGEpCJQaCEp8w4cWgAN+oOFTcFtV4hSKi0jm2UH41iwK5rLifpJ3lbmJnRt4M2Apv5UKi+/R0KI/5OQVAQKLSTtmAJ/TwIHL3h6HNTuBiZy1XQhHiVbq2P9vUnepy4nA2CigXY13RnYPIC63k7qFiiEKBYkJBWBQgtJp9dA+IeQFKu/714b2n4Kfs0L7jWEKMUURWFv1E3m7Yhi27kbhvZGfs4MbObP01UryCRvIcowCUlFoFDnJGWlw/45sPMryND/RUxQO2j9MbhWKdjXEqIUOxevn+S95thlsrT6f+oCXG15vZk/Xep5ySRvIcogCUlFoEgmbqclwPYv4OACULSgMYXgvtByDNi5Fs5rClEKxSfpJ3n/sj+GlHuTvF3sLOnXxJeeIZVwspFJ3kKUFRKSikCRnt2WEAGbJsC5dfr7FvbQ7B146i0wty7c1xaiFElJz2LZwTh+2BXNlaR0AGwsTOnawJv+Tf3wdpZJ3kKUdhKSioAqSwBE74SNH8LVY/r7jt7wzHio+ZJM7hYiD7K0OtaduMrcHVGcufr/Sd4dannwRvMAalV0VLlCIURhkZBUBFRbJ0mng5PLYcvHkHxJ3+ZRVz+527dp0dUhRCmgKAq7IhOYtyOKnREJhvan/J3pE+pL00AX7K3MVaxQCFHQJCQVAdUXk8y6C/u+g53fQGaKvq1KR2g9EVwCi74eIUq401eS+X5nFGuPXyFbp/9n0dREQz1vJ5oGutAs0JU6FR0xM5WjtkKUZBKSioDqIem+1Buw/XM4tFA/udvEDBq8Bi1Gga2LenUJUUJdSbzLj3susvH0NaIT0owes7cyo3FAeZoFutI80FUWqhSiBJKQVASKTUi678Y5/eTu83/p71s6QLN3IeRNMLdStzYhSqi4W3fYFZnAzogb7I68SdLdLKPHKznb0CzQhWaBLoQGuOBoLUNzQhR3efn+Vv248axZs/D19cXKyoqQkBAOHDjw0P6JiYkMHjwYDw8PLC0tCQoKYv369YbHU1JSGD58OD4+PlhbW9O4cWMOHjxotI3U1FSGDBlCxYoVsba2pnr16syZM6dQ9q/IuFaBV5ZC77X6BSgzkmHzBJjZEE6u0M9lEkLkibezDT0aVeK7nsEcGdea1YObMLJNEI38nDEz0RB76w6/7I/lzZ+PUO/jjbzw3W6+3nSeQxdvkaWV3zkhSjpVjyQtW7aM3r17M2fOHEJCQpg2bRrLly/n3LlzVKhQIUf/zMxMmjRpQoUKFfjggw/w8vIiJiYGJycn6tSpA0C3bt04deoUs2fPxtPTk59//plvvvmG06dP4+XlBcDAgQP5+++/+f777/H19WXjxo289dZbrFy5kueee+6xai92R5L+TaeDE8v0k7tTrujbPOvrJ3f7NFa3NiFKidSMbPZH3WRnhP5I04UbxkNzdpZmhAaUp3mgC00DXfEtb4NGIyt9C6G2EjPcFhISQsOGDZk5cyYAOp0Ob29vhg4dyujRo3P0nzNnDlOmTOHs2bOYm+c8rH337l3s7e1Zs2YNHTt2NLQHBwfTvn17Jk2aBEDNmjXp1q0b48aNe2CfRynWIem+zDuwbxbsmgaZqfq2qs/qV+4uH6BqaUKUNpcT77Ir4gY7IxLYFZlA4h3jobmK5azvDc250jigvCxgKYRKSkRIyszMxMbGhhUrVtClSxdDe58+fUhMTGTNmjU5ntOhQwecnZ2xsbFhzZo1uLq68sorrzBq1ChMTU1JSUnBwcGBzZs388wzzxie17RpU8zMzNi2bRugP5J09OhRVq9ejaenJ9u2beO5555j3bp1NG/+eNdIKxEh6b7U67D1MzjyIyg6/eTuhgP0k7ttnNWuTohSR6tT+OdKkuEo0+GY24bLooB+TaZaFZ1ofi801avkhLmcNSdEkcjL97dZEdWUQ0JCAlqtFjc3N6N2Nzc3zp49m+tzoqKi+Pvvv+nZsyfr168nMjKSt956i6ysLCZMmIC9vT2hoaF88sknVKtWDTc3N3799Vf27t1L5cqVDduZMWMGAwcOpGLFipiZmWFiYsL8+fMfGpAyMjLIyMgw3E9OTn7Cn0ARsqsAnaZByBuwaTxEbNRfG+7Yr9B8pL7dzFLtKoUoNUxNNNSu6ETtik4MblWZtIxsDkTfYkfEDXZFJBBxPZXjcYkcj0tkxt+R2FqYEhpQnqaVXWgW5Iq/i60MzQlRDKgWkvJDp9NRoUIF5s2bh6mpKcHBwVy+fJkpU6YwYcIEABYvXsxrr72Gl5cXpqam1K9fnx49enD48GHDdmbMmMG+fftYu3YtPj4+7Nixg8GDB+Pp6UlYWFiurz158mQmTpxYJPtZaCpUg57L4cJW/crd107BpnFwcD6EfQQ1XgD5h1mIAmdraUarqhVoVVU/1/Jq0l12RSQYhuZupWWy+cx1Np+5DoCXk/W9wORCkwAXytnK0JwQaihRw20tWrTA3NyczZs3G9r++usvOnToQEZGBhYW//+HJC0tjeTkZDw8POjWrRupqamsW7eOu3fv4ujoyKpVq4zmLQ0YMIBLly6xYcOGXOvN7UiSt7d3yRhuy41OC8d/hb8nQcpVfVvFhtDmU6gUom5tQpQhOp3C6avJ9wLTDQ5G3ybzX2fGaTRQy8uRZoEuNK3sSrBPOSzMZGhOiPwqEcNtFhYWBAcHs2XLFkNI0ul0bNmyhSFDhuT6nCZNmrBkyRJ0Oh0m965Vdv78eTw8PIwCEoCtrS22trbcvn2b8PBwvvzySwCysrLIysoyPP8+U1NTdA85Td7S0hJLy1I0JGViCvVehRrPw56ZsPtbuHQQfmgD1Tvrjyw5+6tdpRClnomJhppejtT0cmRQywDuZmrZH33TcKTp3LUUTlxK4sSlJGZtvYCNhSkhfs76BS2DXAhwtZOhOSEKiepLAPTp04e5c+fSqFEjpk2bxm+//cbZs2dxc3Ojd+/eeHl5MXnyZADi4uKoUaMGffr0YejQoURERPDaa68xbNgwxo4dC0B4eDiKolClShUiIyN57733sLKyYufOnYYz4lq2bElCQgIzZ87Ex8eH7du3M2jQIL7++msGDRr0WLWXqInbjyMlXj+5++jie5O7zaHRQP2cJZncLYRqriWn3wtMN9gVmUBCaqbR4+4OVvqz5oJcaRJQnvJ2peiPOSEKQYk4u+2+mTNnMmXKFOLj46lbty7Tp08nJEQ/3NOyZUt8fX1ZtGiRof/evXt55513OHbsGF5eXvTv399wdhvAb7/9xpgxY7h06RLOzs68+OKLfPrppzg6/v+q3vHx8YwZM4aNGzdy69YtfHx8GDhwIO+8885j/0VW6kLSfdf+0U/ujrw3pGnlBC3e158NJ5O7hVCVTqdwNj7FEJj2R98iM9v4CHhNLweaVnaleaALwb7lsDQzValaIYqnEhWSSqpSG5Lui9wCG8fB9X/098v5QthE/VCcHNoXolhIz9Jy8OItdkYksOP8Dc7Gpxg9bmVuQohfeZoFutA8yJXACjI0J4SEpCJQ6kMS6Cd3H/tFP7k79Zq+zTtEP7nbu6G6tQkhcrieks7uyIR76zMlcCMlw+hxNwdLmlZ2pVmgC00qu+BqL0eHRdkjIakIlImQdF9GKuyZAXumQ9YdfVuN5/WTu8v5qlmZEOIBFEXh3LUUdkUksCMigf1RN8n4z9BcdQ8HwyrgDXzLYWUuQ3Oi9JOQVATKVEi6L/kqbJ0ER38BFDC1+P/kbutyalcnhHiI9Cwth2NuGxa0/OeK8YK4lmYmNPJzpnmgK00DXajqbi9Dc6JUkpBUBMpkSLov/pR+Mcqorfr71uX0lzhp0B/MZNE7IUqChNSMfw3N3eBasvHQnKu9pX5By0AXmga6UMHeSqVKhShYEpKKQJkOSQCKoj8DbuOHcOPeZWSc/fWTu6t1ksndQpQgiqIQeT2VHfcC0/6oW9zN0hr1qepufy8wudLI1xlrCxmaEyWThKQiUOZD0n3abP3aSls/gzT9JRWoFKqf3F0xWN3ahBD5kpGtH5rbGZHArogETl1J4t/fFBZmJjTydaZpoP5IUzV3B0xM5A8jUTJISCoCEpL+IyNFv2r3npmQfVffVvMleGY8lPNRtzYhxBO5lZZ5b2juBjsjErialG70uIudBU0q6yeANwt0wc1BhuZE8SUhqQhISHqApMuw9VM4tgT95G5LeOpNaDoCrJ3Urk4I8YQUReHCjTT9gpYRCeyNusmdTOOhuSA3O5rdmwAe4ueMjUWJupa6KOUkJBUBCUmPcPW4fr5S9A79fWtnaDkGGvQDU3N1axNCFJjMbB1HYm8bLp1y4vJ/huZMTWjgW46mgS40D3SluocMzQl1SUgqAhKSHoOiQMRG/crdCef0beUrQ+uPoUoHmdwtRCl0Oy2TPRduGobmLifeNXrc2fb+0Jz+5uForVKloqySkFQEJCTlgTYbjvyon9x9J0Hf5tMU2nwCXvXVrU0IUWgURSE6IY1dkQnsOJ/A3gsJpP1naK5yBTuaVnaheZALIX7lsbWUoTlRuCQkFQEJSfmQngy7p8HeWZB9b+Jnra76yd1O3qqWJoQofFlaHcfiEtl5/gY7IxM4HpeI7l/fQOamGupXKkfzIFeaVnahppcjpjI0JwqYhKQiICHpCSRdgi2fwIml+vumlhD6ln5yt5X8LIUoK5LuZLHnQgI7I/UX6L1023hozsnGXD80V9mFZkGueDnJ0Jx4chKSioCEpAJw5Zh+cvfFnfr7Ni7QcjQE95XJ3UKUMYqiEHPzDjsjE9h5/gZ7L9wkJSPbqI+/q60+MAW68lRAeexkaE7kg4SkIiAhqYAoCpzfoJ/cfTNC3+YSpJ/cHdROJncLUUZla3Ucv5TIjvMJ7IpM4FhcItp/jc2ZmeiH5u5fNqV2RScZmhOPRUJSEZCQVMC0WXB4EWybDHdu6tt8m0GbSeBZV83KhBDFQHJ6Fnv/ddZczM07Ro87WpvTOKC8YUFLb2cblSoVxZ2EpCIgIamQpCfBzq9h32zQ3rvgZu3u8Mw4cKyobm1CiGIj9uYddkbqF7TcHZlAcrrx0JxveRvDgpahAeVxsJIhfKEnIakISEgqZImx+sndJ3/T3zezgtAh0HQ4WNqrWpoQonjJ1uo4cTnJsKDl0dhEsv81NGdqoqGet9O9a825UqeiI2amJipWLNQkIakISEgqIpcPQ/iHELtHf9/WFVp9APV6g6lM2hRC5JSSnsW+qFuGS6dEJaQZPW5vZWY0NOdT3lalSoUaJCQVAQlJRUhR4Ow62DQebl3Qt7lWhdafQGBrmdwthHiouFt32BWZwK4I/STwpLtZRo9XcrYxrAAeGuCCo7UMzZVmEpKKgIQkFWiz4NAPsO1zuHtL3+bXQj+526O2urUJIUoErU7h1OUkdkbcYEdEAkdibhsNzZlooK63E00DXWke6EIdbyfMZWiuVJGQVAQkJKnobiLs/Ar2zwFtJqCBuq/A0x+Cg6fa1QkhSpDUjGz2R91k5735TBduGA/N2VmaERpQnuaBLjQNdMW3vA0aOXpdoklIKgISkoqB2zGwZSKc+l1/38waGg+FJm+DpZ26tQkhSqQriXfZFZHAjogb7I5M4PYd46G5iuWs7w3NudI4oDxONhYqVSryS0JSEZCQVIxcOgThYyFun/6+bQV4eizU6wUmpurWJoQosXQ6hX+uJLPj3gTwQzG3yNIaD83VquikP8pU2YV6lcphYSZDc8WdhKQiICGpmFEUOPMHbJ4At6L0bRWq35vcHaZubUKIUuFOZjb7o24ZhuYirqcaPW5rYUpoQHma3rvWnL+LrQzNFUMSkoqAhKRiKjsTDi3QT+5OT9S3BTytD0vuNVUtTQhRusQnpRtWAN8dmcDNtEyjx72crO8FJheaBLhQzlaG5ooDCUlFQEJSMXf3NuyYCvvngi4L0EC9ntDqQ3DwULs6IUQpo9MpnL6azK5I/VGmg9G3ydTqDI9rNFDLy1F/rbnKrgT7yNCcWiQkFQEJSSXErWj95O5/Vunvm9voJ3Y3HgoWsoCcEKJw3M3UcuDiLXae1x9pOnctxehxGwtTQvycaRboSvMgFwJc7WRorohISCoCEpJKmLgD+sndlw7o79u565cMqPuKTO4WQhS6a8nphsUsd0YkkJCaYfS4u4OV/qy5IFeaBJSnvJ2lSpWWfhKSioCEpBJIUeD0atg0ARJj9G1uNaHNJ/p5S0IIUQQUReFsfIphPtOB6FtkZOuM+tT0cqBpZf2ClsG+5bA0kz/mCoqEpCIgIakEy86AA/Nhx5eQnqRvqxymn9ztVl3d2oQQZU56lpaDF++fNZfAmavJRo9bmZsQ4lfesD5TkJsMzT0JCUlFQEJSKXDnFuyYog9MuizQmOjXVmo1Fuzd1K5OCFFG3UjJYHekfkHLnREJ3EgxHpqrYG9puDhvk8ouuNrL0FxeSEgqAhKSSpGbF2DzR3Bmrf6+uS00HQ6hQ8DCRs3KhBBlnKIonL+Wahia2x99k/Qs46G5ah4ONL93lKmBbzmszGVo7mEkJBUBCUmlUOw+/eTuy4f09+094OlxUKe7TO4WQhQL6VlaDsfcNixo+c8V46E5SzMTGvk50zzQlaaBLlR1t5ehuf+QkFQEJCSVUooC/6zUH1lKjNW3udeCNpPAv6WalQkhRA4JqfqhuZ0RCeyKSCA+Od3ocVd7S/2CloEuNA10oYK9lUqVFh8SkoqAhKRSLisdDszTL0iZcW9yd2BbaP0xVKiqbm1CCJELRVGIvJ5qOMq0L+oWd7O0Rn2qutvfC0yuNPJ1xtqi7B0ll5BUBCQklRFpN/VnwR38HnTZ+snd9ftAqw/AroLa1QkhxANlZGs5EpNomM906koS//7GtzAzoZGvM00D9Ueaqrk7YGJS+ofmJCQVAQlJZUxCpP7iuWf/1N+3sNNP7n5qsEzuFkKUCLfSMtkdqR+W2xlxgytJxkNzLnYWNKnsYjhzzs2hdA7NSUgqAhKSyqiLu2HjWLhyVH/fwQueGQ+1uoKJXIdJCFEyKIrChRtp7Lp3lGlv1E3uZBoPzQW52dHs3gTwED9nbCzMVKq2YElIKgISksownQ5O/a6/JlxSnL7Now60+RT8mqlbmxBC5ENmto6jsffOmotM4MSlROOhOVMTgn3K0SzIheaBrlT3KLlDc4UekuLi4tBoNFSsWBGAAwcOsGTJEqpXr87AgQPzV3UJIyFJkJUO+2fDzq8h495puEHt9ZO7XYPUrU0IIZ5A4p1MdkfeZFfkDXacT+By4l2jx51t7w3NVdafNefpZK1SpXlX6CGpWbNmDBw4kF69ehEfH0+VKlWoUaMGERERDB06lPHjx+e7+JJCQpIwSEuAbZ/DoR9A0YLGFBr0g5ZjwNZF7eqEEOKJKIrCxZt32BmhD0z7om6SmpFt1KdyBTuaVnaheZALIX7lsbUsvkNzhR6SypUrx759+6hSpQrTp09n2bJl7N69m40bN/Lmm28SFRWV7+JLCglJIoeECNg0Hs6t19+3sIdmI+CpQWBecv7KEkKIh8nS6jgWl2hYauB4XCK6fyUJc1MN9SuVo3mQK00ru1DTyxHTYjQ0V+ghyc7OjlOnTuHr68tzzz1HkyZNGDVqFLGxsVSpUoW7d+8+eiMlnIQk8UDRO/WTu68e19939NZP7q75kkzuFkKUOkl3stgblcCOe6Ep7pZxBnCyMTcMzTULcsVL5aG5Qg9JISEhtGrVio4dO9KmTRv27dtHnTp12LdvHy+99BKXLl3Kd/ElhYQk8VA6HZxcDls+huR7vw+e9fSTu32bqFubEEIUopibaeyISGBXxA32RN4k5T9Dc/6utvrAFOjKUwHlsSvioblCD0nbtm3j+eefJzk5mT59+vDDDz8A8MEHH3D27FlWrlyZv8pLEAlJ4rFk3YV938HObyAzRd9W9VkImwguldWtTQghClm2VsfxS/eH5hI4FpeI9l9jc2Ym+qG5+5dNqV3RqdCH5opkCQCtVktycjLlypUztF28eBEbGxsqVCj9KxFLSBJ5knoDtk2Gw4v0k7tNzKDBa9BiNNiWV7s6IYQoEsnpWey9cJOdETfYFZHAxZt3jB53tDancUB5w4KW3s4Fv1hvoYeku3fvoigKNjb64mNiYli1ahXVqlWjbdu2+au6hJGQJPLlxjn95O7zG/T3LR2g2bsQ8iaYl87VbYUQ4kHibt0xTADfHZlAcrrx0NwrIZX47PlaBfqahR6S2rRpwwsvvMCbb75JYmIiVatWxdzcnISEBL7++msGDRqU7+JLCglJ4olEbYONH0L8Sf19x0oQNgFqvgia4nMWiBBCFBWtTuHEvaG5XREJHIm9zYTnatDrKZ8CfZ1CD0kuLi5s376dGjVq8P333zNjxgyOHj3K77//zvjx4zlz5ky+iy8pJCSJJ6bTwYmlsOUTSLmib/MK1k/u9glVtzYhhFBZSnoWGo2mwCd25+X7O1/nI9+5cwd7e3sANm7cyAsvvICJiQlPPfUUMTEx+dmkEGWPiQnUfQWGHoZWH4K5LVw+DAvbwbJX4eYFtSsUQgjV2FuZF/mZb/+Vr5BUuXJlVq9eTVxcHOHh4bRp0waA69evy1EVIfLKwgZavAfDjkJwX9CYwJk/YFYI/DUa7txSu0IhhCiT8hWSxo8fz8iRI/H19aVRo0aEhuqHBjZu3Ei9evUKtEAhygx7N+j0LQzaA5Vbgy5Lf2246XVhzwzIzlC7QiGEKFPyFZJeeuklYmNjOXToEOHh4Yb2Z555hm+++SZP25o1axa+vr5YWVkREhLCgQMHHto/MTGRwYMH4+HhgaWlJUFBQaxfv97weEpKCsOHD8fHxwdra2saN27MwYMHc2znzJkzPPfcczg6OmJra0vDhg2JjY3NU+1CFIoK1eDVFdBrFbjVhPQk/STvmQ3h1ErI36odQggh8ijf10hwd3enXr16XLlyxbDCdqNGjahatepjb2PZsmWMGDGCCRMmcOTIEerUqUPbtm25fv16rv0zMzNp3bo1Fy9eZMWKFZw7d4758+fj5eVl6DNgwAA2bdrE4sWLOXnyJG3atCEsLIzLly8b+ly4cIGmTZtStWpVtm3bxokTJxg3bhxWVnIKtihGAp6GN3ZA51lg5w6JMbCiHyxoDbH71a5OCCFKvXyd3abT6Zg0aRJfffUVqampANjb2/Puu+8yduxYTB7z+lQhISE0bNiQmTNnGrbr7e3N0KFDGT16dI7+c+bMYcqUKZw9exZzc/Mcj9+9exd7e3vWrFlDx44dDe3BwcG0b9+eSZMmAdC9e3fMzc1ZvHhxXnfdQM5uE0UqMw32zITd30JWmr6tehf9sgHO/qqWJoQQJUmhn902duxYZs6cyeeff87Ro0c5evQon332GTNmzGDcuHGPtY3MzEwOHz5MWFjY/4sxMSEsLIy9e/fm+py1a9cSGhrK4MGDcXNzo2bNmnz22WdotVoAsrOz0Wq1OY4IWVtbs2vXLkAfxNatW0dQUBBt27alQoUKhISEsHr16ofWm5GRQXJystFNiCJjYQstR8GwI1C/t35y9+nVMLMRbPhAJncLIURhUPLBw8NDWbNmTY721atXK56eno+1jcuXLyuAsmfPHqP29957T2nUqFGuz6lSpYpiaWmpvPbaa8qhQ4eUpUuXKs7OzspHH31k6BMaGqq0aNFCuXz5spKdna0sXrxYMTExUYKCghRFUZSrV68qgGJjY6N8/fXXytGjR5XJkycrGo1G2bZt2wPrnTBhggLkuCUlJT3W/gpRoOJPKcpPzyvKBAf9bXIlRdkzU1GyMtSuTAghirWkpKTH/v7O15GkW7du5Tr3qGrVqty6VXh/0ep0OipUqMC8efMIDg6mW7dujB07ljlz5hj6LF68GEVR8PLywtLSkunTp9OjRw/DEKBOpwOgc+fOvPPOO9StW5fRo0fz7LPPGm3nv8aMGUNSUpLhFhcXV2j7KcQjudWAXivh1d+hQnVIT4TwD2BWI/hntUzuFkKIApCvkFSnTh3DPKJ/mzlzJrVr136sbbi4uGBqasq1a9eM2q9du4a7u3uuz/Hw8CAoKAhTU1NDW7Vq1YiPjyczMxOAgIAAtm/fTmpqKnFxcRw4cICsrCz8/f0Nr2tmZkb16tWNtl2tWrWHnt1maWmJg4OD0U0I1VUOgzd3QafpYOcGt6NheR/4oS3E5TyrUwghxOPLV0j68ssv+eGHH6hevTr9+/enf//+VK9enUWLFjF16tTH2oaFhQXBwcFs2bLF0KbT6diyZYth3aX/atKkCZGRkYajQQDnz5/Hw8MDCwsLo762trZ4eHhw+/ZtwsPD6dy5s+F1GzZsyLlz54z6nz9/Hh+fgr0+jBBFwsQUgvvA0CPQYhSYWUPcflgQBsv7we2LalcohBAlUr5CUosWLTh//jzPP/88iYmJJCYm8sILL/DPP//k6YyxESNGMH/+fH788UfOnDnDoEGDSEtLo1+/fgD07t2bMWPGGPoPGjSIW7du8fbbb3P+/HnWrVvHZ599xuDBgw19wsPD2bBhA9HR0WzatIlWrVpRtWpVwzYB3nvvPZYtW8b8+fOJjIxk5syZ/PHHH7z11lv5+XEIUTxY2kGrD/STu+u+Cmjgn5X69ZU2fgh3E9WuUAghSpaCnAx17NgxxcTEJE/PmTFjhlKpUiXFwsJCadSokbJv3z7DYy1atFD69Olj1H/Pnj1KSEiIYmlpqfj7+yuffvqpkp2dbXh82bJlir+/v2JhYaG4u7srgwcPVhITE3O87oIFC5TKlSsrVlZWSp06dZTVq1fnqe68TPwSQhVXTyjKj8/9f3L35z6Ksne2TO4WQpRpefn+ztc6SQ9y/Phx6tevbzglvzSTdZJEiaAoELlZfyTpxll9m3MAtJ4IVZ8FjUbd+oQQoogV+jpJQogSQqOBwNbw5m54dhrYusKtC7DsVVjYAS4fVrtCIYQotiQkCVEWmJpBg34w7Cg0f08/uTt2D8x/Gn4fAIly3UIhhPivPA23vfDCCw99PDExke3bt8twmxDFXdJl+HsSHP8VUMDUEp56E5q9C1aOalcnhBCFJi/f33kKSf8+Q+xhFi5c+LibLLEkJIlS4epx/Xyl6B36+zblocVo/VEn05zXRxRCiJKu0EKS+D8JSaLUUBSI2Agbx0HCvfXDyleG1h9DlQ4yuVsIUarIxG0hxOPTaCCoLQzaAx2/BhsXuBkJS1+BRc/C5SNqVyiEEKqQkCSE0DM1g4b99ZO7m44AMyuI2QXzW8HKgZAo1ysUQpQtEpKEEMasHCBsAgw5BLW76dtOLIOZDWDzREhPVrc+IYQoIhKShBC5c/KGF+bBwG3g0xSy02HX1zC9Hhz8HrTZalcohBCFSkKSEOLhPOtB3z+h+6/6Cd13EmDduzA7FM5t0E/8FkKIUkhCkhDi0TQaqNoB3toHHabqlwpIOA+/doOfntMvJSCEEKWMhCQhxOMzNYdGr+sndzcZrl+EMnoHzG0BqwbpF6kUQohSQkKSECLvrBz1F8kdchBqvQwocHwJzAiGLZ9ARoraFQohxBOTkCSEyL9yPvDi9/D631CpMWTfhZ1T9ZO7D/0gk7uFECWahCQhxJPzCoZ+66HbL+AcAGk34M93YE4TOL9RJncLIUokCUlCiIKh0UC1Z/WTu9t/CdbOcOMsLHkZFneB+JNqVyiEEHkiIUkIUbDMLCDkDf3k7sbDwNQCorbBnGawejAkX1G7QiGEeCwSkoQQhcPaCdp8op/cXeMFQIFjP+snd2/9DDJS1a5QCCEeSkKSEKJwlfOFlxdC/83gHQJZd2D7FzCjPhz+EXRatSsUQohcSUgSQhQN74bwWjh0/QnK+UHqNfhjGMxpCpGb1a5OCCFykJAkhCg6Gg1U7wyDD0DbyWDlBNdPw88vwuIX4No/alcohBAGEpKEEEXPzAJC39JP7g4dAibmcGGL/qjS2qGQEq92hUIIISFJCKEiG2do+ykMOQDVu4CigyM/wfT6sO1zyExTu0IhRBkmIUkIoT5nf+j6I7y2ESo2hKw02DZZH5aOLJbJ3UIIVUhIEkIUH5VCoP8meHkROPlAajysHQJzm8OFv9WuTghRxkhIEkIULxoN1Hhev75Sm0/1F9O9dgoWPw8/vwTXz6hdoRCijJCQJIQonswsofEQGHYMnnpLP7k7chPMbgx/vA0p19SuUAhRyklIEkIUbzbO0G4yDN4P1Z7TT+4+vEi/GOX2KZB5R+0KhRCllIQkIUTJUD4Aui2GfhvAKxgyU2HrJP1lTo4tAZ1O7QqFEKWMhCQhRMniE6q/xMmLC8CxEqRcgdWDYF5ziNqudnVCiFJEQpIQouQxMYFaL+knd7f+GCwdIf4k/PQcLOkGN86pXaEQohSQkCSEKLnMraDJ2/qVuxu9ASZmcH4DfBcKf46A1BtqVyiEKMEkJAkhSj7b8tDhS3hrP1R9FhQtHFoA0+vBzq8g667aFQohSiAJSUKI0sOlMnT/BfquA896kJkCWz6GGQ3g+FKZ3C2EyBMJSUKI0se3KQz4G174Hhy9IfkSrHoD5reE6J1qVyeEKCEkJAkhSicTE6j9sn5yd9hHYOkAV4/Dj8/Crz3gxnm1KxRCFHMSkoQQpZu5NTR9Rz+5u+HroDGFc+vhu6dg3UhIS1C7QiFEMSUhSQhRNti6QMep8NY+qNJBP7n74Hz95O5d30BWutoVCiGKGQlJQoiyxTUIevwKff4AjzqQkQybP4KZDeDEcpncLYQwkJAkhCib/JrD69vg+bng4AVJcbByAHz/DFzcrXZ1QohiQEKSEKLsMjGBOt1hyCF4ehxY2MGVI7CoA/z6CsSfUrtCIYSKJCQJIYSFDTQfqZ/c3eA10JjAuXUwpwn81geun1G7QiGECiQkCSHEfXYV4Nlv9JO7a7ygbzu9Wn+ZkxX9ISFC1fKEEEVLQpIQQvyXaxV4eSEM2gPVngMUOLUCZjWCVW/CzQtqVyiEKAISkoQQ4kHcakC3xfDGznvLBujg+K8wsyGsGQy3L6pdoRCiEElIEkKIR/GorV824PWtENhGv8bS0Z9hRjD8MRySLqldoRCiEEhIEkKIx+VVH3ouh/6bwL8V6LLh8EL9gpTrRkLyFbUrFEIUIAlJQgiRV96NoPdq6PcX+DYDbaZ+9e5v68JfoyHlmtoVCiEKgIQkIYTIL5/G0PdP/erdlUJBmwH7Z8O3dWDjh3JdOCFKOAlJQgjxpPya648q9VoFXg0g+y7smQHTasPmiXDnltoVCiHyQUKSEEIUBI0GAp6GAZuh5wrwrAdZabDra31Y+vtTuHtb7SqFEHkgIUkIIQqSRgOBrfVnwnX/FdxqQWYK7PgSptWBbV9AepLaVQohHkOxCEmzZs3C19cXKysrQkJCOHDgwEP7JyYmMnjwYDw8PLC0tCQoKIj169cbHk9JSWH48OH4+PhgbW1N48aNOXjw4AO39+abb6LRaJg2bVpB7ZIQoqzTaKBqB3hjB3RdDBWqQ0YSbPtMf2Rp51eQkap2lUKIh1A9JC1btowRI0YwYcIEjhw5Qp06dWjbti3Xr1/PtX9mZiatW7fm4sWLrFixgnPnzjF//ny8vLwMfQYMGMCmTZtYvHgxJ0+epE2bNoSFhXH58uUc21u1ahX79u3D09Oz0PZRCFGGmZhA9efgzd3w0kJwqQLpibDlY/i2Nuz+FjLT1K5SCJELjaIoipoFhISE0LBhQ2bOnAmATqfD29uboUOHMnr06Bz958yZw5QpUzh79izm5uY5Hr979y729vasWbOGjh07GtqDg4Np3749kyZNMrRdvnyZkJAQwsPD6dixI8OHD2f48OGPVXdycjKOjo4kJSXh4OCQx70WQpRZOi2c+h22fQ637l3exNYVmr6jv7iuubW69QlRyuXl+1vVI0mZmZkcPnyYsLAwQ5uJiQlhYWHs3bs31+esXbuW0NBQBg8ejJubGzVr1uSzzz5Dq9UCkJ2djVarxcrKyuh51tbW7Nq1y3Bfp9PRq1cv3nvvPWrUqPHIWjMyMkhOTja6CSFEnpmYQu2uMPgAdJkN5Xwh7QaEf6BfZ2n/PMjOULtKIQQqh6SEhAS0Wi1ubm5G7W5ubsTHx+f6nKioKFasWIFWq2X9+vWMGzeOr776ynCEyN7entDQUD755BOuXLmCVqvl559/Zu/evVy9etWwnS+++AIzMzOGDRv2WLVOnjwZR0dHw83b2zufey2EEICpGdR9BYYcgk7TwdEbUuPhr/f0K3gfXADZmWpXKUSZpvqcpLzS6XRUqFCBefPmERwcTLdu3Rg7dixz5swx9Fm8eDGKouDl5YWlpSXTp0+nR48emJjod/fw4cN8++23LFq0CI1G81ivO2bMGJKSkgy3uLi4Qtk/IUQZY2oOwX1g6BHo+DXYe0LyZVg3Qn9tuCM/gTZL7SqFKJNUDUkuLi6Ymppy7ZrxEv7Xrl3D3d091+d4eHgQFBSEqampoa1atWrEx8eTman/qysgIIDt27eTmppKXFwcBw4cICsrC39/fwB27tzJ9evXqVSpEmZmZpiZmRETE8O7776Lr69vrq9raWmJg4OD0U0IIQqMmQU07A/DjkL7L8HODZJiYe1QmNkAji0BbbbaVQpRpqgakiwsLAgODmbLli2GNp1Ox5YtWwgNDc31OU2aNCEyMhKdTmdoO3/+PB4eHlhYWBj1tbW1xcPDg9u3bxMeHk7nzp0B6NWrFydOnODYsWOGm6enJ++99x7h4eGFsKdCCPGYzK0g5A14+zi0/Uw/qfv2RVg9CL4LgRPL9ZO/hRCFTvXhthEjRjB//nx+/PFHzpw5w6BBg0hLS6Nfv34A9O7dmzFjxhj6Dxo0iFu3bvH2229z/vx51q1bx2effcbgwYMNfcLDw9mwYQPR0dFs2rSJVq1aUbVqVcM2y5cvT82aNY1u5ubmuLu7U6VKlaL9AQghRG7MrSF0sD4stf4YrJ3hZiSsHADfhcKplfCvPxaFEAXPTO0CunXrxo0bNxg/fjzx8fHUrVuXDRs2GCZzx8bGGuYSAXh7exMeHs4777xD7dq18fLy4u2332bUqFGGPklJSYwZM4ZLly7h7OzMiy++yKeffprrkgFCCFGsWdhCk7f1ywPsn6u/JlzCOVjRDypMgZZjoFon/eKVQogCpfo6SSWVrJMkhFBFehLsmwN7Z0LGvaVI3GtDqw8gqJ2EJSEeocSskySEECKPrByh5SgYfgKavwcWdhB/An7tDvNbQcQmkL99hSgQEpKEEKIksi4HT38Iw0/qV+s2t4ErR+GXl2BBG7iwVcKSEE9IQpIQQpRkNs4Q9hG8fQJCh4CZFVw6AIu7wMIOEL1T7QqFKLEkJAkhRGlg5wptP9WfDRcyCEwtIXYP/PgsLHoWYnK/1JMQ4sEkJAkhRGli7w7tP4e3j0HD18HEHC7uhIXtYPHzEHdQ7QqFKDEkJAkhRGnk4Akdp+pX8A7uCyZmcOFvWBAGv7wMl4+oXaEQxZ6EJCGEKM2cvKHTtzD0MNR7FTSmELFRfybcr6/A1RNqVyhEsSUhSQghyoJyvtB5Fgw5CLW7g8YEzq2Duc1gWS+4dlrtCoUodiQkCSFEWVI+AF6YC2/th5ovARo4sxZmN4bl/eDGebUrFKLYkJAkhBBlkWsQvLQA3toL1TsDCvyzUn8R3ZUD4eYFtSsUQnUSkoQQoiyrUA26/gRv7oKqz4KigxPLYGZDWP0W3IpWu0IhVCMhSQghBLjXgu6/wMBt+mvAKVo49gvMbABrh0FirNoVClHkJCQJIYT4P8968MoyGLAFAp4BXTYc+RGm14c/R0DSZbUrFKLISEgSQgiRU8UG0GslvBYOfi1AlwWHFsD0urD+fUiJV7tCIQqdhCQhhBAPVukp6LMW+q4DnyagzYQDc+HbOhA+FlJvqF2hEIVGQpIQQohH822qD0q910DFRpCdDntnwre1YdN4SLupdoVCFDgJSUIIIR6PRgP+LaH/Rnj1d/CsD1l3YPe3+rC05RO4c0vtKoUoMBKShBBC5I1GA5XD4PW/occycK8Nmamwc6p+GG7rZLibqHaVQjwxCUlCCCHyR6OBKu3gjR3Q7RdwqwkZybD9c/2RpR1TICNF7SqFyDcJSUIIIZ6MRgPVnoU3dsLLi8C1KqQnwd+TYFot2PUNZKSqXaUQeaZRFEVRu4iSKDk5GUdHR5KSknBwcFC7HCGEKD50WvhnFWybDDcj9W02LtB0ODToDxY2qpYnyra8fH/LkSQhhBAFy8QUar2kv4ju83OhnB/cSYCNH+rXWdo3B7LS1a5SiEeSkCSEEKJwmJpBne4w5CA8NxOcKkHqNdgwSh+WDsyH7Ay1qxTigSQkCSGEKFym5lC/Fww5DM9OA4eKkHIV1o+EGcFweBFos9SuUogcJCQJIYQoGmYW0KAfDDsCHaaCvQckxcEfb+vD0tGfQZutdpVCGEhIEkIIUbTMLKHR6zDsKLT7HGwrQGIMrBkMsxrC8WX6yd9CqExCkhBCCHWYW8NTg+Dt49D6E7ApD7eiYNVAmBUCJ1eATqd2laIMk5AkhBBCXRY20GQYvH0CnpkA1uXgZgT83h9mN4Z/VktYEqqQkCSEEKJ4sLSDZiP0YanVh2DlCDfOwPI+MLc5nF0HsrSfKEISkoQQQhQvVg7Q4j19WGoxCizs4dpJWPoKzGsB58MlLIkiISFJCCFE8WTtBK0+gOEnoNm7YG4LV4/Dkq7wfRhEbpGwJAqVhCQhhBDFm40zPDNeH5YaDwMza7h8CH5+AX5oB1HbJSyJQiEhSQghRMlg6wJtPtGHpacGg5kVxO2Dn56DRc/Cxd1qVyhKGQlJQgghSha7CtDuMxh2DBoNBFMLiNkFizrAT50h7oDaFYpSQkKSEEKIksnBAzpM0S9K2eA1MDGHqG2woDX8/CJcOqx2haKEk5AkhBCiZHOsCM9+A0MPQ/3eoDGFyM3w/dOwpJt+srcQ+SAhSQghROlQzgeemwFDD0GdV0BjAuc36NdYWtoT4k+pXaEoYSQkCSGEKF2c/eH52TD4INTqCmjg7J8wpwn81geun1G7QlFCSEgSQghROrlUhhfnw1v7oMbz+rbTq+G7UFjRHxIiVC1PFH8SkoQQQpRuFarCy4tg0B6o1glQ4NQKmNUIVr0JNy+oXaEopiQkCSGEKBvcakC3n+GNHRDUHhQdHP8VZjaENUPgdozaFYpiRkKSEEKIssWjDryyFF7/Gyq3BkULRxfDjPrwx3BIuqR2haKYkJAkhBCibPIKhldXQP9N4N8KdNlweCFMrwfrRkLyVbUrFCqTkCSEEKJs824EvVdD3/Xg0xS0mXBwPnxbBzaMgZRralcoVCIhSQghhADwbQL91kGfP8D7KdBmwL7v9GFp44eQlqB2haKISUgSQggh/s2vOby2AXqtAq8GkH0X9syAabVh80S4c0vtCkURkZAkhBBC/JdGAwFPw4DN8Mpy8KgLWWmw62t9WPr7U7ibqHaVopBJSBJCCCEeRKOBoDYwcBt0/xXcakFmCuz4Uh+Wtn8J6clqVykKiYQkIYQQ4lE0GqjaQb/GUtefwLUaZCTB1k9hWi3Y+RVkpKpdpShgEpKEEEKIx2ViAtU761fvfukHcAmC9ETY8jF8Wxt2fwuZd9SuUhQQCUlCCCFEXpmYQM0X9deFe36e/qK6d27CpvH6s+H2fgdZd9WuUjwhCUlCCCFEfpmYQp1uMPggdP4OnHwg7TqEj4Fv68L+eZCdoXaVIp+KRUiaNWsWvr6+WFlZERISwoEDBx7aPzExkcGDB+Ph4YGlpSVBQUGsX7/e8HhKSgrDhw/Hx8cHa2trGjduzMGDBw2PZ2VlMWrUKGrVqoWtrS2enp707t2bK1euFNo+CiGEKMVMzaBeTxh6GDpNB0dvSI2Hv97Tr+B96AfIzlS7SpFHqoekZcuWMWLECCZMmMCRI0eoU6cObdu25fr167n2z8zMpHXr1ly8eJEVK1Zw7tw55s+fj5eXl6HPgAED2LRpE4sXL+bkyZO0adOGsLAwLl++DMCdO3c4cuQI48aN48iRI6xcuZJz587x3HPPFck+CyGEKKVMzSG4jz4sdfwK7D0h+TL8+Q7MCIYjP4E2S+0qxWPSKIqiqFlASEgIDRs2ZObMmQDodDq8vb0ZOnQoo0ePztF/zpw5TJkyhbNnz2Jubp7j8bt372Jvb8+aNWvo2LGjoT04OJj27dszadKkXOs4ePAgjRo1IiYmhkqVKj2y7uTkZBwdHUlKSsLBweFxd1cIIURZkpUOR37Un/2Weu/yJuV8ocUoqNVVfwRKFKm8fH+reiQpMzOTw4cPExYWZmgzMTEhLCyMvXv35vqctWvXEhoayuDBg3Fzc6NmzZp89tlnaLVaALKzs9FqtVhZWRk9z9raml27dj2wlqSkJDQaDU5OTrk+npGRQXJystFNCCGEeChzKwh5A94+Dm0+BRsXuH0RVg+C70LgxHLQadWuUjyAqiEpISEBrVaLm5ubUbubmxvx8fG5PicqKooVK1ag1WpZv34948aN46uvvjIcIbK3tyc0NJRPPvmEK1euoNVq+fnnn9m7dy9Xr+Z+Ref09HRGjRpFjx49HpgqJ0+ejKOjo+Hm7e39BHsuhBCiTDG3hsZDYPgJCJsI1s5wMxJWDoDvQuHUStDp1K5S/Ifqc5LySqfTUaFCBebNm0dwcDDdunVj7NixzJkzx9Bn8eLFKIqCl5cXlpaWTJ8+nR49emBiknN3s7Ky6Nq1K4qiMHv27Ae+7pgxY0hKSjLc4uLiCmX/hBBClGIWttB0uD4sPT0OrJwg4Rys6AdzmsDptaDuLBjxL6qGJBcXF0xNTbl27ZpR+7Vr13B3d8/1OR4eHgQFBWFqampoq1atGvHx8WRm6s8cCAgIYPv27aSmphIXF8eBAwfIysrC39/faFv3A1JMTAybNm166NikpaUlDg4ORjchhBAiXyztoflIfVhqOQYsHeD6afitF8xtDuf+krBUDKgakiwsLAgODmbLli2GNp1Ox5YtWwgNDc31OU2aNCEyMhLdvw5Lnj9/Hg8PDywsLIz62tra4uHhwe3btwkPD6dz586Gx+4HpIiICDZv3kz58uULeO+EEEKIR7ByhJaj9WGp+XtgYQfxJ+DX7jD/aYjYLGFJRaqf3bZs2TL69OnD3LlzadSoEdOmTeO3337j7NmzuLm50bt3b7y8vJg8eTIAcXFx1KhRgz59+jB06FAiIiJ47bXXGDZsGGPHjgUgPDwcRVGoUqUKkZGRvPfee1hZWbFz507Mzc3JysripZde4siRI/z5559Gc6KcnZ1zhK3cyNltQgghClzaTdgzHQ7Mg6x7lzep2AhafQD+LfXXkBNPJC/f36qfe9itWzdu3LjB+PHjiY+Pp27dumzYsMEQXGJjY43mEnl7exMeHs4777xD7dq18fLy4u2332bUqFGGPklJSYwZM4ZLly7h7OzMiy++yKeffmpYMuDy5cusXbsWgLp16xrVs3XrVlq2bFm4Oy2EEELkxrY8tJ4IoUNg9zQ4+D1cOgCLu0Clxvqw5NdM7SrLDNWPJJVUciRJCCFEoUuJh13fwKGFoL13eRO/5tBqLFR6St3aSqgSs06SEEIIIR7C3h3afwHDjkLDAWBiDtE74Ie2sPh5iDv46G2IfJOQJIQQQhR3jl76y5wMOwLBfcHEDC78DQvC4JeX4fIRtSsslSQkCSGEECWFUyXo9C0MOQR1XwWNKURshPmt4NdX4OoJtSssVSQkCSGEECWNsx90mQVDDkLtbqAxgXPrYG4zWNYLrp1Wu8JSQUKSEEIIUVKVD4AX5sFb+6Dmi4AGzqyF2Y1heT+4cV7tCks0CUlCCCFESedaBV76AQbtgeqdAQX+Wam/iO7KgXDzgtoVlkgSkoQQQojSwq06dP0J3twFVTqCooMTy2BmQ1g9GG5Fq11hiSIhSQghhCht3GtBjyUwcBsEtgVFC8d+hpkNYO0wSIxVu8ISQUKSEEIIUVp51oOev8GALRDwDOiy4ciPML0+/DkCki6rXWGxJiFJCCGEKO0qNoBeK6HfBv2K3bosOLQApteDv0bpV/YWOUhIEkIIIcoKn1Do8wf0+VN/LThtBuyfA9/WgfCxkHpD7QqLFQlJQgghRFnj1wz6rYdeq6FiI8hOh70z4dvasGk8pN1Uu8JiQUKSEEIIURZpNBDQCvpvhJ6/g2d9yLoDu7/Vh6Utn8CdW2pXqSoJSUIIIURZptFAYBi8/jf0WAbutSEzFXZO1Q/DbZ0MdxPVrlIVEpKEEEIIoQ9LVdrBGzug289QoQZkJMP2z/VHlnZMgYwUtassUhKShBBCCPF/Gg1U66RfkPLlReBSBdKT4O9JMK027PoGMtPUrrJIaBRFUdQuoiRKTk7G0dGRpKQkHBwc1C5HCCGEKBw6LZxaqT+idDNS32bjAk3fgQavgYWNuvXlUV6+v+VIkhBCCCEezMQUar8Mb+2HLnOgnC/cSYCNY2F6Xdg3B7LS1a6yUEhIEkIIIcSjmZpB3R4w5BA8NwMcK0HqNdgwSr8o5cHvITtD7SoLlIQkIYQQQjw+U3Oo3xuGHoZnvwEHL0i5AuvehRnBcHgRaLPUrrJASEgSQgghRN6ZWejnJA07Cu2ngJ07JMXBH2/rw9LRn0GbrXaVT0RCkhBCCCHyz8wSQgbC28eg7WSwdYXEGFgzGGY1hOPL9JO/SyAJSUIIIYR4cubWEPoWvH0cWn8CNuXhVhSsGgjfPQUnV4BOp3aVeSIhSQghhBAFx8IWmgyDt0/AM+PBygkSzsPv/WF2Y/hndYkJSxKShBBCCFHwLO2g2bsw/CS0GguWjnDjDCzvA3Obw9l1UMyXapSQJIQQQojCY+UALd6H4SegxSiwsIdrJ2HpKzCvJZwPL7ZhSUKSEEIIIQqftRO0+kAflpqOAHNbuHoMlnSF78MgckuxC0sSkoQQQghRdGycIWyCPiw1Hgpm1nD5EPz8AvzQDqK2q12hgYQkIYQQQhQ9WxdoM0l/NtxTb4GpJcTtg5+eg0XPwsXdalcoIUkIIYQQKrJ3g3aT9WGp0UAwtYCLO2FRB/3ClCqSkCSEEEII9Tl4QIcpMPQIBPcDEzPwaaJqSRpFKWazpEqI5ORkHB0dSUpKwsHBQe1yhBBCiNIlMVZ/XTgT0wLdbF6+v80K9JWFEEIIIQqCUyW1K5DhNiGEEEKI3EhIEkIIIYTIhYQkIYQQQohcSEgSQgghhMiFhCQhhBBCiFxISBJCCCGEyIWEJCGEEEKIXEhIEkIIIYTIhYQkIYQQQohcSEgSQgghhMiFhCQhhBBCiFxISBJCCCGEyIWEJCGEEEKIXJipXUBJpSgKAMnJySpXIoQQQojHdf97+/73+MNISMqnlJQUALy9vVWuRAghhBB5lZKSgqOj40P7aJTHiVIiB51Ox5UrV7C3t0ej0RTotpOTk/H29iYuLg4HB4cC3XZxIPtX8pX2fZT9K/lK+z7K/uWfoiikpKTg6emJicnDZx3JkaR8MjExoWLFioX6Gg4ODqXyw3+f7F/JV9r3Ufav5Cvt+yj7lz+POoJ0n0zcFkIIIYTIhYQkIYQQQohcSEgqhiwtLZkwYQKWlpZql1IoZP9KvtK+j7J/JV9p30fZv6IhE7eFEEIIIXIhR5KEEEIIIXIhIUkIIYQQIhcSkoQQQgghciEhSQghhBAiFxKSisCsWbPw9fXFysqKkJAQDhw48ND+y5cvp2rVqlhZWVGrVi3Wr19v9LiiKIwfPx4PDw+sra0JCwsjIiKiMHfhofKyf/Pnz6dZs2aUK1eOcuXKERYWlqN/37590Wg0Rrd27doV9m48VF72cdGiRTnqt7KyMupTkt/Dli1b5tg/jUZDx44dDX2K03u4Y8cOOnXqhKenJxqNhtWrVz/yOdu2baN+/fpYWlpSuXJlFi1alKNPXn+vC1Ne93HlypW0bt0aV1dXHBwcCA0NJTw83KjPRx99lOM9rFq1aiHuxYPldf+2bduW62c0Pj7eqF9xeQ/zun+5/X5pNBpq1Khh6FOc3r/JkyfTsGFD7O3tqVChAl26dOHcuXOPfF5x+C6UkFTIli1bxogRI5gwYQJHjhyhTp06tG3bluvXr+faf8+ePfTo0YP+/ftz9OhRunTpQpcuXTh16pShz5dffsn06dOZM2cO+/fvx9bWlrZt25Kenl5Uu2WQ1/3btm0bPXr0YOvWrezduxdvb2/atGnD5cuXjfq1a9eOq1evGm6//vprUexOrvK6j6BfJfbf9cfExBg9XpLfw5UrVxrt26lTpzA1NeXll1826ldc3sO0tDTq1KnDrFmzHqt/dHQ0HTt2pFWrVhw7dozhw4czYMAAoxCRn89EYcrrPu7YsYPWrVuzfv16Dh8+TKtWrejUqRNHjx416lejRg2j93DXrl2FUf4j5XX/7jt37pxR/RUqVDA8Vpzew7zu37fffmu0X3FxcTg7O+f4HSwu79/27dsZPHgw+/btY9OmTWRlZdGmTRvS0tIe+Jxi812oiELVqFEjZfDgwYb7Wq1W8fT0VCZPnpxr/65duyodO3Y0agsJCVHeeOMNRVEURafTKe7u7sqUKVMMjycmJiqWlpbKr7/+Wgh78HB53b//ys7OVuzt7ZUff/zR0NanTx+lc+fOBV1qvuV1HxcuXKg4Ojo+cHul7T385ptvFHt7eyU1NdXQVtzew/sAZdWqVQ/t8/777ys1atQwauvWrZvStm1bw/0n/ZkVpsfZx9xUr15dmThxouH+hAkTlDp16hRcYQXkcfZv69atCqDcvn37gX2K63uYn/dv1apVikajUS5evGhoK67vn6IoyvXr1xVA2b59+wP7FJfvQjmSVIgyMzM5fPgwYWFhhjYTExPCwsLYu3dvrs/Zu3evUX+Atm3bGvpHR0cTHx9v1MfR0ZGQkJAHbrOw5Gf//uvOnTtkZWXh7Oxs1L5t2zYqVKhAlSpVGDRoEDdv3izQ2h9XfvcxNTUVHx8fvL296dy5M//884/hsdL2Hi5YsIDu3btja2tr1F5c3sO8etTvYEH8zIobnU5HSkpKjt/DiIgIPD098ff3p2fPnsTGxqpUYf7UrVsXDw8PWrduze7duw3tpe09XLBgAWFhYfj4+Bi1F9f3LykpCSDH5+3fist3oYSkQpSQkIBWq8XNzc2o3c3NLcfY+H3x8fEP7X//v3nZZmHJz/7916hRo/D09DT6oLdr146ffvqJLVu28MUXX7B9+3bat2+PVqst0PofR372sUqVKvzwww+sWbOGn3/+GZ1OR+PGjbl06RJQut7DAwcOcOrUKQYMGGDUXpzew7x60O9gcnIyd+/eLZDPfXEzdepUUlNT6dq1q6EtJCSERYsWsWHDBmbPnk10dDTNmjUjJSVFxUofj4eHB3PmzOH333/n999/x9vbm5YtW3LkyBGgYP7tKi6uXLnCX3/9leN3sLi+fzqdjuHDh9OkSRNq1qz5wH7F5bvQrMC2JEQeff755yxdupRt27YZTWzu3r274f9r1apF7dq1CQgIYNu2bTzzzDNqlJonoaGhhIaGGu43btyYatWqMXfuXD755BMVKyt4CxYsoFatWjRq1MiovaS/h2XJkiVLmDhxImvWrDGas9O+fXvD/9euXZuQkBB8fHz47bff6N+/vxqlPrYqVapQpUoVw/3GjRtz4cIFvvnmGxYvXqxiZQXvxx9/xMnJiS5duhi1F9f3b/DgwZw6dUq1+VF5JUeSCpGLiwumpqZcu3bNqP3atWu4u7vn+hx3d/eH9r//37xss7DkZ//umzp1Kp9//jkbN26kdu3aD+3r7++Pi4sLkZGRT1xzXj3JPt5nbm5OvXr1DPWXlvcwLS2NpUuXPtY/uGq+h3n1oN9BBwcHrK2tC+QzUVwsXbqUAQMG8Ntvv+UY2vgvJycngoKCSsR7mJtGjRoZai8t76GiKPzwww/06tULCwuLh/YtDu/fkCFD+PPPP9m6dSsVK1Z8aN/i8l0oIakQWVhYEBwczJYtWwxtOp2OLVu2GB1p+LfQ0FCj/gCbNm0y9Pfz88Pd3d2oT3JyMvv373/gNgtLfvYP9GckfPLJJ2zYsIEGDRo88nUuXbrEzZs38fDwKJC68yK/+/hvWq2WkydPGuovDe8h6E/PzcjI4NVXX33k66j5HubVo34HC+IzURz8+uuv9OvXj19//dVo+YYHSU1N5cKFCyXiPczNsWPHDLWXlvdw+/btREZGPtYfKmq+f4qiMGTIEFatWsXff/+Nn5/fI59TbL4LC2wKuMjV0qVLFUtLS2XRokXK6dOnlYEDBypOTk5KfHy8oiiK0qtXL2X06NGG/rt371bMzMyUqVOnKmfOnFEmTJigmJubKydPnjT0+fzzzxUnJydlzZo1yokTJ5TOnTsrfn5+yt27d4v9/n3++eeKhYWFsmLFCuXq1auGW0pKiqIoipKSkqKMHDlS2bt3rxIdHa1s3rxZqV+/vhIYGKikp6cX+f7lZx8nTpyohIeHKxcuXFAOHz6sdO/eXbGyslL++ecfQ5+S/B7e17RpU6Vbt2452ovbe5iSkqIcPXpUOXr0qAIoX3/9tXL06FElJiZGURRFGT16tNKrVy9D/6ioKMXGxkZ57733lDNnziizZs1STE1NlQ0bNhj6POpnVtTyuo+//PKLYmZmpsyaNcvo9zAxMdHQ591331W2bdumREdHK7t371bCwsIUFxcX5fr168V+/7755htl9erVSkREhHLy5Enl7bffVkxMTJTNmzcb+hSn9zCv+3ffq6++qoSEhOS6zeL0/g0aNEhxdHRUtm3bZvR5u3PnjqFPcf0ulJBUBGbMmKFUqlRJsbCwUBo1aqTs27fP8FiLFi2UPn36GPX/7bfflKCgIMXCwkKpUaOGsm7dOqPHdTqdMm7cOMXNzU2xtLRUnnnmGeXcuXNFsSu5ysv++fj4KECO24QJExRFUZQ7d+4obdq0UVxdXRVzc3PFx8dHef3111X78rkvL/s4fPhwQ183NzelQ4cOypEjR4y2V5LfQ0VRlLNnzyqAsnHjxhzbKm7v4f3Twf97u79Pffr0UVq0aJHjOXXr1lUsLCwUf39/ZeHChTm2+7CfWVHL6z62aNHiof0VRb/sgYeHh2JhYaF4eXkp3bp1UyIjI4t2x+7J6/598cUXSkBAgGJlZaU4OzsrLVu2VP7+++8c2y0u72F+PqOJiYmKtbW1Mm/evFy3WZzev9z2DTD6vSqu34WaezsghBBCCCH+ReYkCSGEEELkQkKSEEIIIUQuJCQJIYQQQuRCQpIQQgghRC4kJAkhhBBC5EJCkhBCCCFELiQkCSGEEELkQkKSEEIUEI1Gw+rVq9UuQwhRQCQkCSFKhb59+6LRaHLc2rVrp3ZpQogSykztAoQQoqC0a9eOhQsXGrVZWlqqVI0QoqSTI0lCiFLD0tISd3d3o1u5cuUA/VDY7Nmzad++PdbW1vj7+7NixQqj5588eZKnn34aa2trypcvz8CBA0lNTTXq88MPP1CjRg0sLS3x8PBgyJAhRo8nJCTw/PPPY2NjQ2BgIGvXri3cnRZCFBoJSUKIMmPcuHG8+OKLHD9+nJ49e9K9e3fOnDkDQFpaGm3btqVcuXIcPHiQ5cuXs3nzZqMQNHv2bAYPHszAgQM5efIka9eupXLlykavMXHiRLp27cqJEyfo0KEDPXv25NatW0W6n0KIAlKgl8sVQgiV9OnTRzE1NVVsbW2Nbp9++qmiKPorkb/55ptGzwkJCVEGDRqkKIqizJs3TylXrpySmppqeHzdunWKiYmJEh8fryiKonh6eipjx459YA2A8uGHHxrup6amKoDy119/Fdh+CiGKjsxJEkKUGq1atWL27NlGbc7Ozob/Dw0NNXosNDSUY8f+1779u54Wx3Ecfx0xOCcmke27iYGFic1kU2ySVUoWO38Bf4FRlMHKYFQyXRP+AYlRioXvcEvpe7rde7vo+j4f0+fH6fT+bK8+531+SJKWy6VisZgsy7rtJ5NJXS4XrddrGYahzWajdDr9yxqi0ehtbFmWvF6vdrvd3x4JwAsRkgC8Dcuyvnz++lfcbvdvPedyue7mhmHocrk8oiQAD0ZPEoBvYzabfZmHw2FJUjgc1mKx0PF4vO1Pp1M5HA6FQiF5PB59fHxoMpk8tWYAr8NNEoC3cT6ftd1u79acTqd8Pp8kaTAYKB6PK5VKqdvtaj6fq9PpSJIKhYIajYZKpZKazab2+72q1aqKxaICgYAkqdlsqlwuy+/3K5PJ6HA4aDqdqlqtPvegAJ6CkATgbYxGIwWDwbu1UCik1Wol6eefZ/1+X5VKRcFgUL1eT5FIRJJkmqbG47FqtZoSiYRM01Qul1Or1bq9q1Qq6XQ6qd1uq16vy+fzKZ/PP++AAJ7KuF6v11cXAQCPZhiGhsOhstnsq0sB8J+gJwkAAMAGIQkAAMAGPUkAvgU6CwD8KW6SAAAAbBCSAAAAbBCSAAAAbBCSAAAAbBCSAAAAbBCSAAAAbBCSAAAAbBCSAAAAbBCSAAAAbHwC0eIQW2amZdQAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 9. Demonstrate the model on sample examples\n",
        "def predict_sentiment(text, model, tokenizer):\n",
        "    encoding = tokenizer(\n",
        "        text,\n",
        "        max_length=128,\n",
        "        padding='max_length',\n",
        "        truncation=True,\n",
        "        return_tensors=\"pt\"\n",
        "    ).to(device)\n",
        "\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        outputs = model(**encoding)\n",
        "        logits = outputs.logits\n",
        "        prediction = torch.argmax(logits, axis=1).item()\n",
        "    return \"Positive\" if prediction == 1 else \"Negative\"\n",
        "\n",
        "sample_texts = [\"good\", \"The plot was dull and boring.\", \"Absolutely loved the cinematography.\"]\n",
        "for text in sample_texts:\n",
        "    sentiment = predict_sentiment(text, model, tokenizer)\n",
        "    print(f\"Review: {text} | Sentiment: {sentiment}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7QJcouCUABBr",
        "outputId": "e6e0ef33-4d00-42cf-a39f-c6e0e8204dae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Review: good | Sentiment: Positive\n",
            "Review: The plot was dull and boring. | Sentiment: Negative\n",
            "Review: Absolutely loved the cinematography. | Sentiment: Positive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 7. Save and load the model\n",
        "torch.save(model.state_dict(), 'bert_sentiment_model.pth')  # Save model\n",
        "print(\"Model saved!\")\n",
        "\n",
        "# Correct way to load from a local .pth file:\n",
        "loaded_model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)\n",
        "loaded_model = get_peft_model(loaded_model, lora_config) # Apply LoRA to the loaded model\n",
        "loaded_model.load_state_dict(torch.load('bert_sentiment_model.pth')) # Load the weights\n",
        "loaded_model.to(device)\n",
        "loaded_model.eval()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ngxNOeo8Kkvz",
        "outputId": "a3ac0235-3e57-47e0-f919-6844da2f718c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model saved!\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
            "<ipython-input-84-18e6b5170451>:18: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
            "  loaded_model.load_state_dict(torch.load('bert_sentiment_model.pth')) # Load the weights\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "PeftModelForSequenceClassification(\n",
              "  (base_model): LoraModel(\n",
              "    (model): BertForSequenceClassification(\n",
              "      (bert): BertModel(\n",
              "        (embeddings): BertEmbeddings(\n",
              "          (word_embeddings): Embedding(30522, 768, padding_idx=0)\n",
              "          (position_embeddings): Embedding(512, 768)\n",
              "          (token_type_embeddings): Embedding(2, 768)\n",
              "          (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
              "          (dropout): Dropout(p=0.1, inplace=False)\n",
              "        )\n",
              "        (encoder): BertEncoder(\n",
              "          (layer): ModuleList(\n",
              "            (0-11): 12 x BertLayer(\n",
              "              (attention): BertAttention(\n",
              "                (self): BertSdpaSelfAttention(\n",
              "                  (query): lora.Linear(\n",
              "                    (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
              "                    (lora_dropout): ModuleDict(\n",
              "                      (default): Dropout(p=0.1, inplace=False)\n",
              "                    )\n",
              "                    (lora_A): ModuleDict(\n",
              "                      (default): Linear(in_features=768, out_features=8, bias=False)\n",
              "                    )\n",
              "                    (lora_B): ModuleDict(\n",
              "                      (default): Linear(in_features=8, out_features=768, bias=False)\n",
              "                    )\n",
              "                    (lora_embedding_A): ParameterDict()\n",
              "                    (lora_embedding_B): ParameterDict()\n",
              "                    (lora_magnitude_vector): ModuleDict()\n",
              "                  )\n",
              "                  (key): Linear(in_features=768, out_features=768, bias=True)\n",
              "                  (value): lora.Linear(\n",
              "                    (base_layer): Linear(in_features=768, out_features=768, bias=True)\n",
              "                    (lora_dropout): ModuleDict(\n",
              "                      (default): Dropout(p=0.1, inplace=False)\n",
              "                    )\n",
              "                    (lora_A): ModuleDict(\n",
              "                      (default): Linear(in_features=768, out_features=8, bias=False)\n",
              "                    )\n",
              "                    (lora_B): ModuleDict(\n",
              "                      (default): Linear(in_features=8, out_features=768, bias=False)\n",
              "                    )\n",
              "                    (lora_embedding_A): ParameterDict()\n",
              "                    (lora_embedding_B): ParameterDict()\n",
              "                    (lora_magnitude_vector): ModuleDict()\n",
              "                  )\n",
              "                  (dropout): Dropout(p=0.1, inplace=False)\n",
              "                )\n",
              "                (output): BertSelfOutput(\n",
              "                  (dense): Linear(in_features=768, out_features=768, bias=True)\n",
              "                  (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
              "                  (dropout): Dropout(p=0.1, inplace=False)\n",
              "                )\n",
              "              )\n",
              "              (intermediate): BertIntermediate(\n",
              "                (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
              "                (intermediate_act_fn): GELUActivation()\n",
              "              )\n",
              "              (output): BertOutput(\n",
              "                (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
              "                (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
              "                (dropout): Dropout(p=0.1, inplace=False)\n",
              "              )\n",
              "            )\n",
              "          )\n",
              "        )\n",
              "        (pooler): BertPooler(\n",
              "          (dense): Linear(in_features=768, out_features=768, bias=True)\n",
              "          (activation): Tanh()\n",
              "        )\n",
              "      )\n",
              "      (dropout): Dropout(p=0.1, inplace=False)\n",
              "      (classifier): ModulesToSaveWrapper(\n",
              "        (original_module): Linear(in_features=768, out_features=2, bias=True)\n",
              "        (modules_to_save): ModuleDict(\n",
              "          (default): Linear(in_features=768, out_features=2, bias=True)\n",
              "        )\n",
              "      )\n",
              "    )\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "# 8. Evaluate the model on the test set\n",
        "predictions = []\n",
        "true_labels = []\n",
        "\n",
        "model.eval()  # Set the model to evaluation mode\n",
        "with torch.no_grad():\n",
        "    for i, (input_ids, attention_mask, labels) in enumerate(test_loader):\n",
        "        if i >= 10:\n",
        "          break\n",
        "        input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "        outputs = model(input_ids, attention_mask=attention_mask)\n",
        "        logits = outputs.logits\n",
        "        preds = torch.argmax(logits, axis=1)\n",
        "        predictions.extend(preds.cpu().numpy())\n",
        "        true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "accuracy = accuracy_score(true_labels, predictions)\n",
        "print(f\"Test Accuracy: {accuracy:.4f}\")\n",
        "\n",
        "# Print the classification report\n",
        "print(\"\\nClassification Report:\\n\")\n",
        "print(classification_report(true_labels, predictions))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lW3y_mml7qYQ",
        "outputId": "9c3c7424-afe0-4aab-afcb-0188338d959f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy: 0.5203\n",
            "\n",
            "Classification Report:\n",
            "\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.55      0.40      0.46       332\n",
            "           1       0.50      0.65      0.57       308\n",
            "\n",
            "    accuracy                           0.52       640\n",
            "   macro avg       0.53      0.53      0.51       640\n",
            "weighted avg       0.53      0.52      0.51       640\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "GPT2"
      ],
      "metadata": {
        "id": "IIBaLjHfMAIr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, Dataset\n",
        "from transformers import GPT2Tokenizer, GPT2ForSequenceClassification\n",
        "from sklearn.metrics import accuracy_score, classification_report\n",
        "import numpy as np\n",
        "from datasets import load_dataset\n",
        "import matplotlib.pyplot as plt\n",
        "from peft import LoraConfig, get_peft_model\n",
        "from torch.cuda.amp import autocast, GradScaler\n",
        "\n",
        "# 1. Check if GPU is available and set device\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(f\"Using device: {device}\")\n",
        "\n",
        "# Load dataset\n",
        "dataset = load_dataset(\"imdb\")\n",
        "\n",
        "# Sample 10% from train and split test into 80% for test, 20% for validation\n",
        "train_data = list(zip(dataset['train']['text'], dataset['train']['label']))\n",
        "train_data_sampled = np.random.choice(len(train_data), size=int(len(train_data) * 0.1), replace=False)\n",
        "train_data_sampled = [train_data[i] for i in train_data_sampled]\n",
        "\n",
        "test_data = list(zip(dataset['test']['text'], dataset['test']['label']))\n",
        "val_size = int(len(test_data) * 0.2)\n",
        "test_data, val_data = random_split(test_data, [len(test_data) - val_size, val_size])\n",
        "\n",
        "# Unzip data into features and labels\n",
        "X_train, y_train = zip(*train_data_sampled)\n",
        "X_test, y_test = zip(*test_data)\n",
        "X_val, y_val = zip(*val_data)\n",
        "\n",
        "# Tokenization and Data Preparation\n",
        "class SentimentDataset(Dataset):\n",
        "    def __init__(self, texts, labels, tokenizer, max_len=128):\n",
        "        self.texts = texts\n",
        "        self.labels = labels\n",
        "        self.tokenizer = tokenizer\n",
        "        self.max_len = max_len\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.texts)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        text = self.texts[idx]\n",
        "        label = self.labels[idx]\n",
        "        encoding = self.tokenizer(\n",
        "            text,\n",
        "            max_length=self.max_len,\n",
        "            padding='max_length',\n",
        "            truncation=True,\n",
        "            return_tensors=\"pt\"\n",
        "        )\n",
        "        input_ids = encoding['input_ids'].squeeze(0)  # Remove batch dimension\n",
        "        attention_mask = encoding['attention_mask'].squeeze(0)  # Remove batch dimension\n",
        "        return input_ids, attention_mask, torch.tensor(label, dtype=torch.long)\n",
        "\n",
        "# Load GPT-2 tokenizer\n",
        "tokenizer = GPT2Tokenizer.from_pretrained('gpt2')\n",
        "tokenizer.pad_token = tokenizer.eos_token  # Set padding token to eos_token\n",
        "\n",
        "# Create DataLoaders\n",
        "train_dataset = SentimentDataset(X_train, y_train, tokenizer)\n",
        "val_dataset = SentimentDataset(X_val, y_val, tokenizer)\n",
        "test_dataset = SentimentDataset(X_test, y_test, tokenizer)\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True, pin_memory=True)\n",
        "val_loader = DataLoader(val_dataset, batch_size=8, shuffle=False, pin_memory=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=8, shuffle=False, pin_memory=True)\n",
        "\n",
        "# Define GPT-2-based model with PEFT LoRA\n",
        "lora_config = LoraConfig(\n",
        "    r=8, lora_alpha=32, lora_dropout=0.1, task_type=\"SEQ_CLS\"\n",
        ")\n",
        "\n",
        "base_model = GPT2ForSequenceClassification.from_pretrained('gpt2', num_labels=2)\n",
        "# Update the pad_token_id in the model config\n",
        "base_model.config.pad_token_id = base_model.config.eos_token_id\n",
        "model = get_peft_model(base_model, lora_config)\n",
        "model = model.to(device)\n",
        "\n",
        "# Define loss function and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.AdamW(model.parameters(), lr=2e-5)\n",
        "\n",
        "# Mixed precision setup\n",
        "scaler = GradScaler()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GBDlaC9eL-3H",
        "outputId": "7c1aa796-04fc-4488-ca33-d73913a701e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device: cuda\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of GPT2ForSequenceClassification were not initialized from the model checkpoint at gpt2 and are newly initialized: ['score.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
            "/usr/local/lib/python3.10/dist-packages/peft/tuners/lora/layer.py:1150: UserWarning: fan_in_fan_out is set to False but the target module is `Conv1D`. Setting fan_in_fan_out to True.\n",
            "  warnings.warn(\n",
            "<ipython-input-88-883fb13d3ce2>:88: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n",
            "  scaler = GradScaler()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Training loop\n",
        "epochs = 3\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "\n",
        "for epoch in range(epochs):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    for batch_idx, (input_ids, attention_mask, labels) in enumerate(train_loader):\n",
        "        input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "\n",
        "        # Automatic mixed precision\n",
        "        optimizer.zero_grad()\n",
        "        with autocast():\n",
        "            outputs = model(input_ids, attention_mask=attention_mask, labels=labels)\n",
        "            loss = outputs.loss\n",
        "        scaler.scale(loss).backward()\n",
        "        scaler.step(optimizer)\n",
        "        scaler.update()\n",
        "\n",
        "        running_loss += loss.item()\n",
        "\n",
        "    train_loss = running_loss / len(train_loader)\n",
        "    train_losses.append(train_loss)\n",
        "    print(f\"Epoch [{epoch+1}/{epochs}], Training Loss: {train_loss:.4f}\")\n",
        "\n",
        "    # Validation\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    predictions = []\n",
        "    true_labels = []\n",
        "    with torch.no_grad():\n",
        "        for input_ids, attention_mask, labels in val_loader:\n",
        "            input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "            with autocast():\n",
        "                outputs = model(input_ids, attention_mask=attention_mask, labels=labels)\n",
        "                loss = outputs.loss\n",
        "            val_loss += loss.item()\n",
        "            logits = outputs.logits\n",
        "            preds = torch.argmax(logits, axis=1)\n",
        "            predictions.extend(preds.cpu().numpy())\n",
        "            true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "    val_loss = val_loss / len(val_loader)\n",
        "    val_losses.append(val_loss)\n",
        "    accuracy = accuracy_score(true_labels, predictions)\n",
        "    print(f\"Validation Loss: {val_loss:.4f}, Validation Accuracy: {accuracy:.4f}\")\n",
        "\n",
        "# Plot training and validation loss\n",
        "plt.plot(train_losses, label='Training Loss')\n",
        "plt.plot(val_losses, label='Validation Loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.legend()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 804
        },
        "id": "YtVjY61zMJZX",
        "outputId": "f4568cb4-dfd2-4a54-dc03-1473720fa67c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-89-8ee8152d93e7>:14: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
            "  with autocast():\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/3], Training Loss: 1.1634\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-89-8ee8152d93e7>:35: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
            "  with autocast():\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Loss: 0.7673, Validation Accuracy: 0.5074\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-89-8ee8152d93e7>:14: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
            "  with autocast():\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [2/3], Training Loss: 0.7337\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-89-8ee8152d93e7>:35: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
            "  with autocast():\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Loss: 0.7294, Validation Accuracy: 0.5452\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-89-8ee8152d93e7>:14: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
            "  with autocast():\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [3/3], Training Loss: 0.6926\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-89-8ee8152d93e7>:35: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
            "  with autocast():\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Loss: 0.6829, Validation Accuracy: 0.5972\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": [
        "\n",
        "# Evaluate the model on the test set\n",
        "predictions = []\n",
        "true_labels = []\n",
        "\n",
        "model.eval()\n",
        "with torch.no_grad():\n",
        "    for i, (input_ids, attention_mask, labels) in enumerate(test_loader):\n",
        "        input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "        with autocast():\n",
        "            outputs = model(input_ids, attention_mask=attention_mask)\n",
        "            logits = outputs.logits\n",
        "            preds = torch.argmax(logits, axis=1)\n",
        "            predictions.extend(preds.cpu().numpy())\n",
        "            true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "accuracy = accuracy_score(true_labels, predictions)\n",
        "print(f\"Test Accuracy: {accuracy:.4f}\")\n",
        "\n",
        "# Print the classification report\n",
        "print(\"\\nClassification Report:\\n\")\n",
        "print(classification_report(true_labels, predictions))\n"
      ],
      "metadata": {
        "id": "ZIlyTP7WMOtF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "GPT2 - simple"
      ],
      "metadata": {
        "id": "ea94b9opNEAi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, Dataset\n",
        "from transformers import GPT2Tokenizer, GPT2ForSequenceClassification\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import accuracy_score, classification_report\n",
        "import numpy as np\n",
        "from datasets import load_dataset\n",
        "import matplotlib.pyplot as plt\n",
        "from peft import LoraConfig, get_peft_model\n",
        "\n",
        "# 1. Check if GPU is available and set device\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(f\"Using device: {device}\")\n",
        "\n",
        "# Load dataset\n",
        "dataset = load_dataset(\"imdb\")\n",
        "\n",
        "# Sample 10% from train and split test into 80% for test, 20% for validation\n",
        "train_data = list(zip(dataset['train']['text'], dataset['train']['label']))\n",
        "train_data_sampled = np.random.choice(len(train_data), size=int(len(train_data) * 0.1), replace=False)\n",
        "train_data_sampled = [train_data[i] for i in train_data_sampled]\n",
        "\n",
        "test_data = list(zip(dataset['test']['text'], dataset['test']['label']))\n",
        "val_size = int(len(test_data) * 0.2)\n",
        "test_data, val_data = random_split(test_data, [len(test_data) - val_size, val_size])\n",
        "\n",
        "# Unzip data into features and labels\n",
        "X_train, y_train = zip(*train_data_sampled)\n",
        "X_test, y_test = zip(*test_data)\n",
        "X_val, y_val = zip(*val_data)\n",
        "\n",
        "# Print lengths\n",
        "print(len(X_train), len(X_test), len(X_val))\n",
        "\n",
        "# Tokenization and Data Preparation\n",
        "class SentimentDataset(Dataset):\n",
        "    def __init__(self, texts, labels, tokenizer, max_len=128):\n",
        "        self.texts = texts\n",
        "        self.labels = labels\n",
        "        self.tokenizer = tokenizer\n",
        "        self.max_len = max_len\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.texts)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        text = self.texts[idx]\n",
        "        label = self.labels[idx]\n",
        "        encoding = self.tokenizer(\n",
        "            text,\n",
        "            max_length=self.max_len,\n",
        "            padding='max_length',\n",
        "            truncation=True,\n",
        "            return_tensors=\"pt\"\n",
        "        )\n",
        "        input_ids = encoding['input_ids'].squeeze(0)  # Remove batch dimension\n",
        "        attention_mask = encoding['attention_mask'].squeeze(0)  # Remove batch dimension\n",
        "        return input_ids, attention_mask, torch.tensor(label, dtype=torch.long)\n",
        "\n",
        "# Load GPT-2 tokenizer\n",
        "tokenizer = GPT2Tokenizer.from_pretrained('gpt2')\n",
        "tokenizer.pad_token = tokenizer.eos_token  # Set padding token to eos_token\n",
        "\n",
        "# Create DataLoaders\n",
        "train_dataset = SentimentDataset(X_train, y_train, tokenizer)\n",
        "val_dataset = SentimentDataset(X_val, y_val, tokenizer)\n",
        "test_dataset = SentimentDataset(X_test, y_test, tokenizer)\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True)\n",
        "val_loader = DataLoader(val_dataset, batch_size=4, shuffle=False)\n",
        "test_loader = DataLoader(test_dataset, batch_size=4, shuffle=False)\n",
        "\n",
        "# Define GPT-2-based model with PEFT LoRA\n",
        "lora_config = LoraConfig(\n",
        "    r=8, lora_alpha=32, lora_dropout=0.1, task_type=\"SEQ_CLS\"\n",
        ")\n",
        "\n",
        "base_model = GPT2ForSequenceClassification.from_pretrained('gpt2', num_labels=2)\n",
        "# Update the pad_token_id in the model config\n",
        "base_model.config.pad_token_id = base_model.config.eos_token_id\n",
        "model = get_peft_model(base_model, lora_config)\n",
        "model = model.to(device)\n",
        "\n",
        "# Define loss function and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.AdamW(model.parameters(), lr=2e-5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HKXw17iKNGY4",
        "outputId": "e52672f5-2348-4de0-9700-65951164db48"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device: cuda\n",
            "2500 20000 5000\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of GPT2ForSequenceClassification were not initialized from the model checkpoint at gpt2 and are newly initialized: ['score.weight']\n",
            "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Training loop\n",
        "epochs = 3\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "\n",
        "for epoch in range(epochs):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    for batch_idx, (input_ids, attention_mask, labels) in enumerate(train_loader):\n",
        "        input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)\n",
        "        loss = outputs.loss\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item()\n",
        "\n",
        "    train_loss = running_loss / len(train_loader)\n",
        "    train_losses.append(train_loss)\n",
        "    print(f\"Epoch [{epoch+1}/{epochs}], Training Loss: {train_loss:.4f}\")\n",
        "\n",
        "    # Validation\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    predictions = []\n",
        "    true_labels = []\n",
        "    with torch.no_grad():\n",
        "        for input_ids, attention_mask, labels in val_loader:\n",
        "            input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "            outputs = model(input_ids, attention_mask=attention_mask, labels=labels)\n",
        "            loss = outputs.loss\n",
        "            val_loss += loss.item()\n",
        "            logits = outputs.logits\n",
        "            preds = torch.argmax(logits, axis=1)\n",
        "            predictions.extend(preds.cpu().numpy())\n",
        "            true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "    val_loss = val_loss / len(val_loader)\n",
        "    val_losses.append(val_loss)\n",
        "    accuracy = accuracy_score(true_labels, predictions)\n",
        "    print(f\"Validation Loss: {val_loss:.4f}, Validation Accuracy: {accuracy:.4f}\")\n",
        "\n",
        "# Plot training and validation loss\n",
        "plt.plot(train_losses, label='Training Loss')\n",
        "plt.plot(val_losses, label='Validation Loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 576
        },
        "id": "59s27SoDNNkp",
        "outputId": "0919e5a1-e0c5-41ae-cb55-233d417ac15d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/3], Training Loss: 1.0605\n",
            "Validation Loss: 0.7983, Validation Accuracy: 0.5172\n",
            "Epoch [2/3], Training Loss: 0.7014\n",
            "Validation Loss: 0.6964, Validation Accuracy: 0.5936\n",
            "Epoch [3/3], Training Loss: 0.6221\n",
            "Validation Loss: 0.6041, Validation Accuracy: 0.6980\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": [
        "# Evaluate the model on the test set\n",
        "predictions = []\n",
        "true_labels = []\n",
        "\n",
        "model.eval()\n",
        "with torch.no_grad():\n",
        "    for i, (input_ids, attention_mask, labels) in enumerate(test_loader):\n",
        "        if i >= 10:\n",
        "          break\n",
        "        input_ids, attention_mask, labels = input_ids.to(device), attention_mask.to(device), labels.to(device)\n",
        "        outputs = model(input_ids, attention_mask=attention_mask)\n",
        "        logits = outputs.logits\n",
        "        preds = torch.argmax(logits, axis=1)\n",
        "        predictions.extend(preds.cpu().numpy())\n",
        "        true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "accuracy = accuracy_score(true_labels, predictions)\n",
        "print(f\"Test Accuracy: {accuracy:.4f}\")\n",
        "\n",
        "# Print the classification report\n",
        "print(\"\\nClassification Report:\\n\")\n",
        "print(classification_report(true_labels, predictions))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lll-9ftFNRU6",
        "outputId": "7ed120c7-951c-4bdb-9435-18e52f4e53c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy: 0.6250\n",
            "\n",
            "Classification Report:\n",
            "\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.93      0.48      0.63        27\n",
            "           1       0.46      0.92      0.62        13\n",
            "\n",
            "    accuracy                           0.62        40\n",
            "   macro avg       0.70      0.70      0.62        40\n",
            "weighted avg       0.78      0.62      0.63        40\n",
            "\n"
          ]
        }
      ]
    }
  ]
}