code/models/VGG19_240529.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Training and evaluation of model for PAI-scoring\n",
        "2024.05.31 Gerald Torgersen\n",
        "# Model: VGG19\n",
        "# Data\n",
        "- csv files with column for filename, PAI, weight\n",
        "- RGB clips of radiographs centered around apex, 224 x 224 pixels\n",
        "\n",
        "The weight in the data refers to the quality of scoring."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n_6JaXgwaI-T",
        "outputId": "4b7eb692-9dde-435d-dd99-d02daab79059"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler\n",
        "from torchvision import transforms\n",
        "from torchvision.models import resnet50\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.utils.class_weight import compute_class_weight\n",
        "from PIL import Image\n",
        "from collections import Counter\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lwJA2l2mdC8-"
      },
      "outputs": [],
      "source": [
        "# Custom dataset\n",
        "class CustomDataset(Dataset):\n",
        "    def __init__(self, data, transform=None):\n",
        "        self.data = data\n",
        "        self.transform = transform\n",
        "\n",
        "        # Normalize class labels to 0-based\n",
        "        self.data['PAI'] = self.data['PAI'] - 1\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        img_name = self.data.iloc[idx]['filename']\n",
        "        root_dir = self.data.iloc[idx]['root_dir']\n",
        "        img_path = os.path.join(root_dir, img_name)\n",
        "        if os.path.exists(img_path):\n",
        "            image = Image.open(img_path).convert('RGB')\n",
        "        else:\n",
        "            raise FileNotFoundError(f\"Image {img_name} not found in the root directory.\")\n",
        "\n",
        "        label = self.data.iloc[idx]['PAI']\n",
        "        weight = self.data.iloc[idx]['weight']\n",
        "\n",
        "        if self.transform:\n",
        "            image = self.transform(image)\n",
        "\n",
        "        return image, label, weight\n",
        "\n",
        "\n",
        "# Early stopping class\n",
        "class EarlyStopping:\n",
        "    def __init__(self, patience=10, min_delta=0.001):\n",
        "        self.patience = patience\n",
        "        self.min_delta = min_delta\n",
        "        self.best_loss = np.inf\n",
        "        self.counter = 0\n",
        "\n",
        "    def __call__(self, val_loss):\n",
        "        if val_loss < self.best_loss - self.min_delta:\n",
        "            self.best_loss = val_loss\n",
        "            self.counter = 0\n",
        "            print(f'Validation loss improved to {val_loss:.4f}, resetting counter.')\n",
        "            return False\n",
        "        else:\n",
        "            self.counter += 1\n",
        "            print(f'Validation loss did not improve. Counter: {self.counter}/{self.patience}')\n",
        "            if self.counter >= self.patience:\n",
        "                print(\"Early stopping triggered.\")\n",
        "                return True\n",
        "            return False\n",
        "\n",
        "# Function to save the checkpoint\n",
        "def save_checkpoint(model, optimizer, epoch, filename):\n",
        "    state = {\n",
        "        'epoch': epoch,\n",
        "        'state_dict': model.state_dict(),\n",
        "        'optimizer': optimizer.state_dict(),\n",
        "    }\n",
        "    torch.save(state, filename)\n",
        "\n",
        "# Function to load the checkpoint\n",
        "def load_checkpoint(model, optimizer, filename):\n",
        "    if os.path.isfile(filename):\n",
        "        print(f\"Loading checkpoint '{filename}'\")\n",
        "        checkpoint = torch.load(filename)\n",
        "        model.load_state_dict(checkpoint['state_dict'])\n",
        "        optimizer.load_state_dict(checkpoint['optimizer'])\n",
        "        start_epoch = checkpoint['epoch']\n",
        "        return model, optimizer, start_epoch\n",
        "    else:\n",
        "        raise FileNotFoundError\n",
        "\n",
        "# Enhanced data augmentation\n",
        "data_transforms = {\n",
        "    'train': transforms.Compose([\n",
        "        transforms.RandomHorizontalFlip(),\n",
        "        transforms.RandomRotation(15),\n",
        "        transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.2),\n",
        "        transforms.RandomResizedCrop(224, scale=(0.8, 1.0)),  # Slight zoom in/out\n",
        "        transforms.RandomAffine(degrees=0, translate=(0.1, 0.1), scale=(0.9, 1.1)),  # Translation and scaling\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize(mean=[0.37887412, 0.37887412, 0.37887412], std=[0.09176591, 0.09176591, 0.09176591])\n",
        "    ]),\n",
        "    'val': transforms.Compose([\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize(mean=[0.37887412, 0.37887412, 0.37887412], std=[0.09176591, 0.09176591, 0.09176591])\n",
        "    ]),\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UEygYn0QdR8t"
      },
      "outputs": [],
      "source": [
        "# Load and combine data one ore more datasets\n",
        "all_data = pd.DataFrame()\n",
        "csv_files = [\"path1/data1.csv\", \"path2/data2.csv\"] # Replace with your csv paths\n",
        "root_dirs = [\"images_path1\", \"images_path2\"] # Replace with your image paths\n",
        "\n",
        "for csv_file, root_dir in zip(csv_files, root_dirs):\n",
        "    data = pd.read_csv(csv_file)\n",
        "    data['root_dir'] = root_dir  # Add the root directory to the dataframe\n",
        "    all_data = pd.concat([all_data, data], ignore_index=True)\n",
        "\n",
        "# Split the combined dataset into training and validation sets\n",
        "train_data, val_data = train_test_split(all_data, test_size=0.2, random_state=42, stratify=all_data['PAI'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q1rxTSzL18PX",
        "outputId": "086feee9-c8d2-4689-829b-5fca8921d2d0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Statistics for All data set:\n",
            "   Class  Count Percentage (%)\n",
            "0      1    231           20.6\n",
            "1      3    465           41.4\n",
            "2      2    187           16.7\n",
            "3      5     55            4.9\n",
            "4      4    185           16.5\n"
          ]
        }
      ],
      "source": [
        "from collections import Counter\n",
        "\n",
        "# Function to display dataset statistics\n",
        "def display_dataset_statistics(data, name):\n",
        "    class_counts = Counter(data['PAI'])\n",
        "    total_samples = len(data)\n",
        "    class_percentages = {cls: count / total_samples * 100 for cls, count in class_counts.items()}\n",
        "\n",
        "    stats_df = pd.DataFrame({\n",
        "        'Class': list(class_counts.keys()),\n",
        "        'Count': list(class_counts.values()),\n",
        "        'Percentage (%)': [f\"{percentage:.1f}\" for percentage in class_percentages.values()]\n",
        "    })\n",
        "\n",
        "    print(f\"\\nStatistics for {name} set:\")\n",
        "    print(stats_df)\n",
        "\n",
        "# Display statistics for training and validation sets\n",
        "display_dataset_statistics(all_data, 'All data')  # Using the balanced training data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K1LMfmDurJdY",
        "outputId": "b261aeca-6a5d-489e-ed47-7358a72b30fe"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training dataset size: 1860\n",
            "Validation dataset size: 225\n"
          ]
        }
      ],
      "source": [
        "# Handle unbalanced data by ramdom oversampling\n",
        "\n",
        "from imblearn.over_sampling import RandomOverSampler\n",
        "\n",
        "# Oversample the training data\n",
        "ros = RandomOverSampler(random_state=42)\n",
        "train_data_resampled, _ = ros.fit_resample(train_data, train_data['PAI'])\n",
        "\n",
        "# Function to create weighted sampler\n",
        "def create_weighted_sampler(data):\n",
        "    weights = data['weight'].values\n",
        "    sampler = WeightedRandomSampler(weights, len(weights))\n",
        "    return sampler\n",
        "\n",
        "# Create datasets\n",
        "train_dataset = CustomDataset(train_data_resampled, transform=data_transforms['train'])\n",
        "val_dataset = CustomDataset(val_data, transform=data_transforms['val'])\n",
        "\n",
        "train_sampler = create_weighted_sampler(train_data_resampled)\n",
        "train_loader = DataLoader(train_dataset, batch_size=32, sampler=train_sampler)\n",
        "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n",
        "\n",
        "\n",
        "print(f'Training dataset size: {len(train_dataset)}')\n",
        "print(f'Validation dataset size: {len(val_dataset)}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T_m-vYaUufBP",
        "outputId": "a8601d7f-523c-4db9-9f15-52f8ae74ecbb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Statistics for Training set:\n",
            "   Class  Count Percentage (%)\n",
            "0      3    372           20.0\n",
            "1      4    372           20.0\n",
            "2      2    372           20.0\n",
            "3      1    372           20.0\n",
            "4      0    372           20.0\n",
            "\n",
            "Statistics for Validation set:\n",
            "   Class  Count Percentage (%)\n",
            "0      0     46           20.4\n",
            "1      2     93           41.3\n",
            "2      3     37           16.4\n",
            "3      1     38           16.9\n",
            "4      4     11            4.9\n"
          ]
        }
      ],
      "source": [
        "# Function to display dataset statistics\n",
        "def display_dataset_statistics(data, name):\n",
        "    class_counts = Counter(data['PAI'])\n",
        "    total_samples = len(data)\n",
        "    class_percentages = {cls: count / total_samples * 100 for cls, count in class_counts.items()}\n",
        "\n",
        "    stats_df = pd.DataFrame({\n",
        "        'Class': list(class_counts.keys()),\n",
        "        'Count': list(class_counts.values()),\n",
        "        'Percentage (%)': [f\"{percentage:.1f}\" for percentage in class_percentages.values()]\n",
        "    })\n",
        "\n",
        "    print(f\"\\nStatistics for {name} set:\")\n",
        "    print(stats_df)\n",
        "\n",
        "# Display statistics for training and validation sets\n",
        "display_dataset_statistics(train_data_resampled, 'Training')  # Using the balanced training data\n",
        "display_dataset_statistics(val_data, 'Validation')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7YbWV-fDdXAy",
        "outputId": "508b0952-6125-4247-cc57-865528a5c90d"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=VGG19_BN_Weights.IMAGENET1K_V1`. You can also use `weights=VGG19_BN_Weights.DEFAULT` to get the most up-to-date weights.\n",
            "  warnings.warn(msg)\n"
          ]
        }
      ],
      "source": [
        "# Load and modify the VGG19 model\n",
        "import torchvision.models as models\n",
        "\n",
        "# Load and modify the VGG19 model\n",
        "model = models.vgg19_bn(pretrained=True)\n",
        "\n",
        "\n",
        "# Customize for the number of classes in your dataset\n",
        "num_features = model.classifier[6].in_features\n",
        "features = list(model.classifier.children())[:-1]  # Remove the last layer\n",
        "features.extend([nn.Linear(num_features, 5)])  # Add the last layer with 5 classes\n",
        "model.classifier = nn.Sequential(*features)  # Replace the model classifier\n",
        "\n",
        "# Move model to device\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "model = model.to(device)\n",
        "\n",
        "# Define the criterion\n",
        "criterion = nn.CrossEntropyLoss(reduction='none')\n",
        "\n",
        "# Define optimizer, scheduler, and loss function\n",
        "optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=0.0001, weight_decay=1e-4)\n",
        "scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10, eta_min=1e-6)\n",
        "\n",
        "# Early stopping class (assuming it's defined as before)\n",
        "early_stopping = EarlyStopping(patience=10, min_delta=0.00001)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ac_mqWpRnjZw"
      },
      "outputs": [],
      "source": [
        "# Lists to collect training data\n",
        "train_loss_list = []\n",
        "val_loss_list = []\n",
        "train_accuracy_list = []\n",
        "val_accuracy_list = []\n",
        "mae_list = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-T8WYS8MdJr8",
        "outputId": "57d5e1f4-0e5d-4926-83af-01752e7d0c91"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "No checkpoint found. Starting training from scratch.\n",
            "Starting epoch 1/40\n",
            "Epoch 1/40 - Train Loss: 9.5231, Train Accuracy: 0.3129, Validation Loss: 1.7238, Validation Accuracy: 0.2756, MAE: 1.1733\n",
            "Validation loss improved to 1.7238, resetting counter.\n",
            "Starting epoch 2/40\n",
            "Epoch 2/40 - Train Loss: 5.9058, Train Accuracy: 0.5484, Validation Loss: 1.9227, Validation Accuracy: 0.2711, MAE: 1.0889\n",
            "Validation loss did not improve. Counter: 1/10\n",
            "Starting epoch 3/40\n",
            "Epoch 3/40 - Train Loss: 3.7506, Train Accuracy: 0.6570, Validation Loss: 1.8111, Validation Accuracy: 0.3289, MAE: 1.0756\n",
            "Validation loss did not improve. Counter: 2/10\n",
            "Starting epoch 4/40\n",
            "Epoch 4/40 - Train Loss: 2.4527, Train Accuracy: 0.7070, Validation Loss: 1.9000, Validation Accuracy: 0.3378, MAE: 0.8622\n",
            "Validation loss did not improve. Counter: 3/10\n",
            "Starting epoch 5/40\n",
            "Epoch 5/40 - Train Loss: 1.7785, Train Accuracy: 0.7833, Validation Loss: 2.0872, Validation Accuracy: 0.3378, MAE: 0.8933\n",
            "Validation loss did not improve. Counter: 4/10\n",
            "Starting epoch 6/40\n",
            "Epoch 6/40 - Train Loss: 1.5709, Train Accuracy: 0.8000, Validation Loss: 1.8074, Validation Accuracy: 0.4444, MAE: 0.7689\n",
            "Validation loss did not improve. Counter: 5/10\n",
            "Starting epoch 7/40\n",
            "Epoch 7/40 - Train Loss: 1.2329, Train Accuracy: 0.8140, Validation Loss: 1.7592, Validation Accuracy: 0.4667, MAE: 0.7600\n",
            "Validation loss did not improve. Counter: 6/10\n",
            "Starting epoch 8/40\n",
            "Epoch 8/40 - Train Loss: 0.9766, Train Accuracy: 0.8522, Validation Loss: 1.7720, Validation Accuracy: 0.4667, MAE: 0.7778\n",
            "Validation loss did not improve. Counter: 7/10\n",
            "Starting epoch 9/40\n",
            "Epoch 9/40 - Train Loss: 0.9385, Train Accuracy: 0.8581, Validation Loss: 1.8033, Validation Accuracy: 0.4667, MAE: 0.7911\n",
            "Validation loss did not improve. Counter: 8/10\n",
            "Starting epoch 10/40\n",
            "Epoch 10/40 - Train Loss: 0.8477, Train Accuracy: 0.8656, Validation Loss: 1.7754, Validation Accuracy: 0.4756, MAE: 0.7911\n",
            "Validation loss did not improve. Counter: 9/10\n",
            "Starting epoch 11/40\n",
            "Epoch 11/40 - Train Loss: 0.8115, Train Accuracy: 0.8753, Validation Loss: 1.8424, Validation Accuracy: 0.4578, MAE: 0.8000\n",
            "Validation loss did not improve. Counter: 10/10\n",
            "Early stopping triggered.\n",
            "Early stopping\n"
          ]
        }
      ],
      "source": [
        "import time  # Import time to measure the duration of each epoch\n",
        "import torch.nn.functional as F\n",
        "\n",
        "# Path to save the checkpoint\n",
        "check_point_path = 'ConvNeXt_model_checkpoint.pth'\n",
        "\n",
        "# Initialize start_epoch and total_epochs\n",
        "start_epoch = 0\n",
        "total_epochs = 40\n",
        "\n",
        "# Attempt to load checkpoint\n",
        "try:\n",
        "    model, optimizer, start_epoch = load_checkpoint(model, optimizer, check_point_path)\n",
        "    total_epochs = start_epoch + 10\n",
        "except FileNotFoundError:\n",
        "    start_epoch = 0\n",
        "    total_epochs = 40\n",
        "    print(\"No checkpoint found. Starting training from scratch.\")\n",
        "\n",
        "# Lists to store the probabilities for each class\n",
        "all_probs = []\n",
        "all_true_labels = []\n",
        "\n",
        "for epoch in range(start_epoch, total_epochs):\n",
        "    epoch_start_time = time.time()  # Start timing the epoch\n",
        "    print(f'Starting epoch {epoch+1}/{total_epochs}')\n",
        "\n",
        "    train_loss = 0.0\n",
        "    train_corrects = 0\n",
        "    val_loss = 0.0\n",
        "    val_corrects = 0\n",
        "\n",
        "    all_probs = []\n",
        "    all_true_labels = []\n",
        "\n",
        "    model.train()\n",
        "    for batch_idx, (inputs, labels, weights) in enumerate(train_loader):\n",
        "        inputs, labels, weights = inputs.to(device), labels.to(device), weights.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        weighted_loss = (loss * weights).mean()  # Apply weights to the loss\n",
        "        weighted_loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        train_loss += weighted_loss.item() * inputs.size(0)\n",
        "        _, preds = torch.max(outputs, 1)\n",
        "        train_corrects += torch.sum(preds == labels.data)\n",
        "\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for batch_idx, (inputs, labels, _) in enumerate(val_loader):\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "            loss = criterion(outputs, labels)\n",
        "\n",
        "            val_loss += loss.mean().item() * inputs.size(0)  # Use mean for validation loss\n",
        "            _, preds = torch.max(outputs, 1)\n",
        "            val_corrects += torch.sum(preds == labels.data)\n",
        "\n",
        "            # Collect true labels and probabilities for each class\n",
        "            probs = torch.softmax(outputs, dim=1)\n",
        "            all_probs.extend(probs.cpu().numpy())\n",
        "            all_true_labels.extend(labels.cpu().numpy())\n",
        "\n",
        "    mae = mean_absolute_error(all_true_labels, [np.argmax(p) for p in all_probs])\n",
        "    mae_list.append(mae)\n",
        "\n",
        "    train_loss = train_loss / len(train_loader.dataset)\n",
        "    train_accuracy = train_corrects.double() / len(train_loader.dataset)\n",
        "    val_loss = val_loss / len(val_loader.dataset)\n",
        "    val_accuracy = val_corrects.double() / len(val_loader.dataset)\n",
        "\n",
        "    train_loss_list.append(train_loss)\n",
        "    train_accuracy_list.append(train_accuracy)\n",
        "    val_loss_list.append(val_loss)\n",
        "    val_accuracy_list.append(val_accuracy)\n",
        "\n",
        "    print(f'Epoch {epoch+1}/{total_epochs} - '\n",
        "          f'Train Loss: {train_loss:.4f}, '\n",
        "          f'Train Accuracy: {train_accuracy:.4f}, '\n",
        "          f'Validation Loss: {val_loss:.4f}, '\n",
        "          f'Validation Accuracy: {val_accuracy:.4f}, '\n",
        "          f'MAE: {mae:.4f}')\n",
        "\n",
        "    save_checkpoint(model, optimizer, epoch + 1, check_point_path)\n",
        "\n",
        "    if early_stopping(val_loss):\n",
        "        print(\"Early stopping\")\n",
        "        break\n",
        "\n",
        "    scheduler.step()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 718
        },
        "id": "MqE_Wl1EudBl",
        "outputId": "ae6a6b34-acc0-435e-ce60-a67124633c8e"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwwAAAK9CAYAAACJnusfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABiHUlEQVR4nO3deZiN9f/H8deZwZl9MJaxjn3fQiFlya5kKyGFVHwbSraaUpZkhIpSorJGEqHlG1kyKksMsoSMfRmMwWCYg5nz+8O3+Z27cTNHM3PP8nxc131dnc99n/t+zzlXNe95fT73bXM6nU4BAAAAwC14WF0AAAAAgMyLhgEAAACAKRoGAAAAAKZoGAAAAACYomEAAAAAYIqGAQAAAIApGgYAAAAApmgYAAAAAJiiYQAAAABgioYBAG5h//79atmypQIDA2Wz2bR06dI0Pf/hw4dls9k0a9asND1vVtakSRM1adLE6jIAAP9AwwAg0zpw4ID69u2rMmXKyMvLSwEBAWrYsKEmT56sq1evpuu1e/bsqZ07d+rtt9/W3LlzVbdu3XS9Xkbq1auXbDabAgICbvk57t+/XzabTTabTRMnTnT7/CdPntTIkSO1ffv2NKgWAGC1XFYXAAC38sMPP+jxxx+X3W7X008/rWrVqunatWv69ddfNXToUO3evVvTp09Pl2tfvXpVGzZs0Ouvv67+/funyzVCQkJ09epV5c6dO13Ofye5cuXSlStX9N1336lLly6GffPmzZOXl5cSEhLu6twnT57UqFGjVKpUKdWqVSvV7/vpp5/u6noAgPRFwwAg0zl06JC6du2qkJAQrVmzRkWKFEneFxoaqqioKP3www/pdv2YmBhJUt68edPtGjabTV5eXul2/jux2+1q2LChvvzyyxQNw/z58/Xwww9r8eLFGVLLlStX5OPjozx58mTI9QAA7mFKEoBMZ/z48bp8+bI+//xzQ7Pwt3Llyumll15Kfn3jxg299dZbKlu2rOx2u0qVKqXXXntNDofD8L5SpUrpkUce0a+//qr77rtPXl5eKlOmjObMmZN8zMiRIxUSEiJJGjp0qGw2m0qVKiXp5lSev//Z1ciRI2Wz2QxjK1eu1AMPPKC8efPKz89PFStW1GuvvZa832wNw5o1a/Tggw/K19dXefPmVfv27bVnz55bXi8qKkq9evVS3rx5FRgYqN69e+vKlSvmH+w/dO/eXT/++KMuXLiQPLZ582bt379f3bt3T3H8uXPnNGTIEFWvXl1+fn4KCAhQmzZt9McffyQfs3btWt17772SpN69eydPbfr752zSpImqVaumyMhINWrUSD4+Psmfyz/XMPTs2VNeXl4pfv5WrVopX758OnnyZKp/VgDA3aNhAJDpfPfddypTpozuv//+VB3/7LPP6s0331Tt2rX1/vvvq3HjxgoPD1fXrl1THBsVFaXHHntMLVq00Lvvvqt8+fKpV69e2r17tySpU6dOev/99yVJ3bp109y5czVp0iS36t+9e7ceeeQRORwOjR49Wu+++64effRR/fbbb7d936pVq9SqVSudOXNGI0eO1KBBg7R+/Xo1bNhQhw8fTnF8ly5ddOnSJYWHh6tLly6aNWuWRo0aleo6O3XqJJvNpm+++SZ5bP78+apUqZJq166d4viDBw9q6dKleuSRR/Tee+9p6NCh2rlzpxo3bpz8y3vlypU1evRoSdLzzz+vuXPnau7cuWrUqFHyeWJjY9WmTRvVqlVLkyZNUtOmTW9Z3+TJk1WwYEH17NlTiYmJkqRp06bpp59+0ocffqiiRYum+mcFAPwLTgDIROLi4pySnO3bt0/V8du3b3dKcj777LOG8SFDhjglOdesWZM8FhIS4pTkXLduXfLYmTNnnHa73Tl48ODksUOHDjklOSdMmGA4Z8+ePZ0hISEpahgxYoTT9T+n77//vlOSMyYmxrTuv68xc+bM5LFatWo5CxUq5IyNjU0e++OPP5weHh7Op59+OsX1nnnmGcM5O3bs6AwKCjK9puvP4evr63Q6nc7HHnvM2axZM6fT6XQmJiY6g4ODnaNGjbrlZ5CQkOBMTExM8XPY7Xbn6NGjk8c2b96c4mf7W+PGjZ2SnJ988skt9zVu3NgwtmLFCqck55gxY5wHDx50+vn5OTt06HDHnxEAkHZIGABkKhcvXpQk+fv7p+r4//73v5KkQYMGGcYHDx4sSSnWOlSpUkUPPvhg8uuCBQuqYsWKOnjw4F3X/E9/r31YtmyZkpKSUvWe6Ohobd++Xb169VL+/PmTx2vUqKEWLVok/5yu+vXrZ3j94IMPKjY2NvkzTI3u3btr7dq1OnXqlNasWaNTp07dcjqSdHPdg4fHzf9tJCYmKjY2Nnm61datW1N9Tbvdrt69e6fq2JYtW6pv374aPXq0OnXqJC8vL02bNi3V1wIA/Hs0DAAylYCAAEnSpUuXUnX8kSNH5OHhoXLlyhnGg4ODlTdvXh05csQwXrJkyRTnyJcvn86fP3+XFaf0xBNPqGHDhnr22WdVuHBhde3aVQsXLrxt8/B3nRUrVkyxr3Llyjp79qzi4+MN4//8WfLlyydJbv0sbdu2lb+/v7766ivNmzdP9957b4rP8m9JSUl6//33Vb58edntdhUoUEAFCxbUjh07FBcXl+prFitWzK0FzhMnTlT+/Pm1fft2ffDBBypUqFCq3wsA+PdoGABkKgEBASpatKh27drl1vv+uejYjKen5y3HnU7nXV/j7/n1f/P29ta6deu0atUqPfXUU9qxY4eeeOIJtWjRIsWx/8a/+Vn+Zrfb1alTJ82ePVtLliwxTRckaezYsRo0aJAaNWqkL774QitWrNDKlStVtWrVVCcp0s3Pxx3btm3TmTNnJEk7d+50670AgH+PhgFApvPII4/owIED2rBhwx2PDQkJUVJSkvbv328YP336tC5cuJB8x6O0kC9fPsMdhf72zxRDkjw8PNSsWTO99957+vPPP/X2229rzZo1+vnnn2957r/r3LdvX4p9e/fuVYECBeTr6/vvfgAT3bt317Zt23Tp0qVbLhT/26JFi9S0aVN9/vnn6tq1q1q2bKnmzZun+ExS27ylRnx8vHr37q0qVaro+eef1/jx47V58+Y0Oz8A4M5oGABkOsOGDZOvr6+effZZnT59OsX+AwcOaPLkyZJuTqmRlOJORu+9954k6eGHH06zusqWLau4uDjt2LEjeSw6OlpLliwxHHfu3LkU7/37AWb/vNXr34oUKaJatWpp9uzZhl/Ad+3apZ9++in550wPTZs21VtvvaUpU6YoODjY9DhPT88U6cXXX3+tEydOGMb+bmxu1Vy565VXXtHRo0c1e/ZsvffeeypVqpR69uxp+jkCANIeD24DkOmULVtW8+fP1xNPPKHKlSsbnvS8fv16ff311+rVq5ckqWbNmurZs6emT5+uCxcuqHHjxvr99981e/ZsdejQwfSWnXeja9eueuWVV9SxY0e9+OKLunLliqZOnaoKFSoYFv2OHj1a69at08MPP6yQkBCdOXNGH3/8sYoXL64HHnjA9PwTJkxQmzZt1KBBA/Xp00dXr17Vhx9+qMDAQI0cOTLNfo5/8vDw0PDhw+943COPPKLRo0erd+/euv/++7Vz507NmzdPZcqUMRxXtmxZ5c2bV5988on8/f3l6+urevXqqXTp0m7VtWbNGn388ccaMWJE8m1eZ86cqSZNmuiNN97Q+PHj3TofAODukDAAyJQeffRR7dixQ4899piWLVum0NBQvfrqqzp8+LDeffddffDBB8nHfvbZZxo1apQ2b96sgQMHas2aNQoLC9OCBQvStKagoCAtWbJEPj4+GjZsmGbPnq3w8HC1a9cuRe0lS5bUjBkzFBoaqo8++kiNGjXSmjVrFBgYaHr+5s2ba/ny5QoKCtKbb76piRMnqn79+vrtt9/c/mU7Pbz22msaPHiwVqxYoZdeeklbt27VDz/8oBIlShiOy507t2bPni1PT0/169dP3bp1U0REhFvXunTpkp555hndc889ev3115PHH3zwQb300kt69913tXHjxjT5uQAAt2dzurM6DgAAAECOQsIAAAAAwBQNAwAAAABTNAwAAAAATNEwAAAAADBFwwAAAADAFA0DAAAAAFM0DAAAAABMZcsnPZcfutzqEpCB3n6yhtUlIAM1KlPQ6hKQgfJ48netnMTH7ml1CchAXpn4t1Dve/pbdu2r26ZYdm0z/JcYAAAAgKlM3NsBAAAAFrDxN3VXfBoAAAAATNEwAAAAADDFlCQAAADAlc1mdQWZCgkDAAAAAFMkDAAAAIArFj0b8GkAAAAAMEXCAAAAALhiDYMBCQMAAAAAUzQMAAAAAEwxJQkAAABwxaJnAz4NAAAAAKZIGAAAAABXLHo2IGEAAAAAYIqGAQAAAIAppiQBAAAArlj0bMCnAQAAAMAUCQMAAADgikXPBiQMAAAAAEyRMAAAAACuWMNgwKcBAAAAwBQNAwAAAABTTEkCAAAAXLHo2YCEAQAAAIApEgYAAADAFYueDfg0AAAAAJiiYQAAAABgiilJAAAAgCsWPRuQMAAAAAAwRcIAAAAAuGLRswGfBgAAAABTJAwAAACAKxIGAz4NAAAAAKZoGAAAAACYYkoSAAAA4MqD26q6ImEAAAAAYIqEAQAAAHDFomcDPg0AAAAApmgYAAAAAJhiShIAAADgysaiZ1ckDAAAAABMkTAAAAAArlj0bMCnAQAAAGRBU6dOVY0aNRQQEKCAgAA1aNBAP/74Y/L+Jk2ayGazGbZ+/fq5fR0SBgAAAMBVFlnDULx4cY0bN07ly5eX0+nU7Nmz1b59e23btk1Vq1aVJD333HMaPXp08nt8fHzcvg4NAwAAAJAFtWvXzvD67bff1tSpU7Vx48bkhsHHx0fBwcH/6jpMSQIAAAAyCYfDoYsXLxo2h8Nxx/clJiZqwYIFio+PV4MGDZLH582bpwIFCqhatWoKCwvTlStX3K6JhgEAAABwZfOwbAsPD1dgYKBhCw8PNy11586d8vPzk91uV79+/bRkyRJVqVJFktS9e3d98cUX+vnnnxUWFqa5c+eqR48e7n8cTqfTedcfZiZVfuhyq0tABnr7yRpWl4AM1KhMQatLQAbK48nftXISH7un1SUgA3ll4onx3i0nWHbtC9+9mCJRsNvtstvttzz+2rVrOnr0qOLi4rRo0SJ99tlnioiISG4aXK1Zs0bNmjVTVFSUypYtm+qaMvFXBQAAAFjAwkXPt2sObiVPnjwqV66cJKlOnTravHmzJk+erGnTpqU4tl69epLkdsPAn24AAACAbCIpKcl0zcP27dslSUWKFHHrnCQMAAAAQBYUFhamNm3aqGTJkrp06ZLmz5+vtWvXasWKFTpw4IDmz5+vtm3bKigoSDt27NDLL7+sRo0aqUYN96Zz0zAAAAAArrLIk57PnDmjp59+WtHR0QoMDFSNGjW0YsUKtWjRQseOHdOqVas0adIkxcfHq0SJEurcubOGDx/u9nVoGAAAAIAs6PPPPzfdV6JECUVERKTJdWgYAAAAAFdZ5EnPGYWGIQvp27SMWlYvrDIFfeW4kaithy9own//0qGY+ORjCvjn0SsPV1TDCgXka/fUoTPxmrrmoFbsPG1h5bhbh//8Q79+95VOHvpLl87HqtuQt1Tl3geS96/5epZ2rl+juNgYeebKpaKlK6h51z4qUT7lrdSQ9SxdtEDLFn+lU9EnJUmlypRTzz79VL/hgxZXhvQwe8Z0RaxZpSOHD8pu91L1mrX0wouDFVKqtNWlIR0tmD9Ps2d+rrNnY1ShYiW9+tobqu7m/HIgvWWNCVqQJN1XNp/mrT+qx6dsVK/pW5Tb06aZz9WVd+7/v2/1hK41VLqgr/rN3KpH3v1NP+06rck9aqlKUX8LK8fduuZIUHBIWT3yzEu33B9UpLge6f2S+k/4XM+O+kD5CgZr9tvDFH/xQsYWinRRsFCw+vZ/WZ/OWajps79S7br36fUhA3ToQJTVpSEdbIvcos5duunT2V9q8tTPdOPGDQ184Vldver+U1mRNSz/8b+aOD5cfV8I1YKvl6hixUr6T98+io2Ntbo0WPjgtswoc1aFW+rzWaS+2XJCUacva2/0Jb3y1U4Vy+etasUDko+5JySv5v52VDuOxenYuav6ePVBXbx6XVWLB1pYOe5WhXvqqXnXPqpy363/olzzgeYqW6OO8hcuqsIlSqv10y/IcTVep44cyOBKkR4aNmqi+g0bqXjJEJUIKaXnXnhJ3j4++nPXH1aXhnQw6aPpevjRjipTtrzKV6ik4aPG6tSpaO3980+rS0M6mTt7pjo91kUdOnZW2XLlNHzEKHl5eWnpN4utLg0woGHIwvy8ckuSLly5njy27cgFPVwzWIHeuWWzSQ/XDJY9t4c2HThnVZnIIDduXNeW1d/Ly8dXwSHlrC4HaSwxMVGrf/qvEq5eVdXqtawuBxng8qVLkqSAQP7gkx1dv3ZNe/7crfoN7k8e8/DwUP3692vHH9ssrAxIKVOvYTh27JhGjBihGTNmmB7jcDhSPJzCeeOabLnypHd5lrLZpOGPVtKWQ+e1//Tl5PEX527X5B61tGV0M11PTFLCtUSFzt6mo7FE2tnVvsgNWjh5tK5fc8gvb5B6vj5RvgH8gpFdHIj6S6HPPKlr167J29tHYyZMVqkyqX86J7KmpKQkTZo4TjVq1VbZcuWtLgfp4PyF80pMTFRQUJBhPCgoSIcOHbSoKiRj0bNBpk4Yzp07p9mzZ9/2mPDwcAUGBhq2c5sWZlCF1hnZsYrKB/vr5XnbDeMDW5VXgHcuPT3td3WavEEzfjmsyT1qqUKwnzWFIt2VrlpLL4z/TM+NnqLyte7VV5NG6XLceavLQhopGVJan81brKkz56t95y4aO/J1HT7IlLPsbuK4t3TwwH69FT7R6lIAwNqE4dtvv73t/oMH79xhh4WFadCgQYax2iPW/puyMr03O1RW08oF1f3j33Uq7v/TlZJB3nr6gRC1mfirov6XOuyNvqS6pfOpx/0l9eY3zIPNjvJ4eSsouJiCgoupRIUqev+lHopc81817vik1aUhDeTOnVvFS5SUJFWsXFV7/9ytRQu+0JDXRlhcGdLLxHFj9NsvEZr62RwVKhxsdTlIJ/ny5pOnp2eKBc6xsbEqUKCARVUhWSZdfGwVSxuGDh06yGazyel0mh5ju0MkZLfbZbfbje/JxtOR3uxQWS2qFVaPT37X8fNXDfu8/ne3pH9+nklJd/4ckX04nU4l3rh+5wORJSU5k3T92jWry0A6cDqdevedtxXx8yp9/OksFS1W3OqSkI5y58mjylWqatPGDXqoWXNJN6eibdq0QV279bC4OsDI0vapSJEi+uabb5SUlHTLbevWrVaWl+mM7FhF7WsX1eD5fyjecUMF/POogH8e2XPd/BoPnonX4Zh4vdW5qmqUCFTJIG8906iUGpYP0qrdPIchK3IkXFX04ShFH755G80LZ6IVfThKF86e1rWEq1r55ac69tefuhBzSicO7tOSqe/o0rkYVa3f2OLKkRamT3lff2zdouiTJ3Qg6i9Nn/K+tkduVvM2D1tdGtLBxHFvacV/v9OosRPk4+Or2LMxij0bo4SEBKtLQzp5qmdvfbNoob5dukQHDxzQmNEjdfXqVXXo2Mnq0gADSxOGOnXqKDIyUu3bt7/l/julDznNk/ffnJYw7z/1DOOvfLVT32w5oRtJTj07I1JD21bQtN615WP31JGzVzTsq52K2HvWipLxL508sE8zRr+c/PrHOR9Lku5p3Ertnh2kmBPHtC1ihK5cipOPf4CKla2oPiM/UOESPOgpOzh//pzGjnxNsWdj5Ovnr7LlKmjCh9N0b7377/xmZDnffL1AkhT6XE/D+PCRb+vhRztaURLSWes2bXX+3Dl9POUDnT0bo4qVKuvjaZ8piClJ1mNKkoHNaeFv5L/88ovi4+PVunXrW+6Pj4/Xli1b1Lixe38tLT90eVqUhyzi7Sd5ImZO0qhMQatLQAbK48n/tHMSH7vnnQ9CtuGVie/V6d3uY8uuffW7Fyy7thlLv6oHH7z1w6j+5uvr63azAAAAAPwrrP004E83AAAAAEzRMAAAAAAwlYlnjwEAAAAWYNGzAZ8GAAAAAFMkDAAAAIArFj0bkDAAAAAAMEXCAAAAALhiDYMBnwYAAAAAUzQMAAAAAEwxJQkAAABwxaJnAxIGAAAAAKZIGAAAAAAXNhIGAxIGAAAAAKZoGAAAAACYYkoSAAAA4IIpSUYkDAAAAABMkTAAAAAArggYDEgYAAAAAJgiYQAAAABcsIbBiIQBAAAAgCkaBgAAAACmmJIEAAAAuGBKkhEJAwAAAABTJAwAAACACxIGIxIGAAAAAKZoGAAAAACYYkoSAAAA4IIpSUYkDAAAAABMkTAAAAAArggYDEgYAAAAAJgiYQAAAABcsIbBiIQBAAAAgCkaBgAAAACmmJIEAAAAuGBKkhEJAwAAAABTJAwAAACACxIGIxIGAAAAAKZoGAAAAACYYkoSAAAA4IIpSUYkDAAAAABMkTAAAAAArggYDEgYAAAAAJgiYQAAAABcsIbBiIQBAAAAgCkaBgAAAACmmJIEAAAAuGBKkhEJAwAAAABTJAwAAACACxIGIxIGAAAAAKZoGAAAAACYYkoSAAAA4IoZSQYkDAAAAABMkTAAAAAALlj0bETCAAAAAMAUCQMAAADggoTBKFs2DN8PbmR1CchAqw+esboEZKBvdp2wugRkoKfqlLS6BGSg64lJVpeADOSVi4kuWQXfFAAAAABT2TJhAAAAAO4WU5KMSBgAAACALGjq1KmqUaOGAgICFBAQoAYNGujHH39M3p+QkKDQ0FAFBQXJz89PnTt31unTp92+Dg0DAAAA4MJms1m2uaN48eIaN26cIiMjtWXLFj300ENq3769du/eLUl6+eWX9d133+nrr79WRESETp48qU6dOrn/eTidTqfb78rk9p26YnUJyEAsegayLxY9A9mXvz3z/t26aN9vLLv2oQ8elsPhMIzZ7XbZ7fZUvT9//vyaMGGCHnvsMRUsWFDz58/XY489Jknau3evKleurA0bNqh+/fqprinzflMAAABADhMeHq7AwEDDFh4efsf3JSYmasGCBYqPj1eDBg0UGRmp69evq3nz5snHVKpUSSVLltSGDRvcqolFzwAAAIArC9c8h4WFadCgQYax26ULO3fuVIMGDZSQkCA/Pz8tWbJEVapU0fbt25UnTx7lzZvXcHzhwoV16tQpt2qiYQAAAAAyCXemH0lSxYoVtX37dsXFxWnRokXq2bOnIiIi0rQmGgYAAADARVa6rWqePHlUrlw5SVKdOnW0efNmTZ48WU888YSuXbumCxcuGFKG06dPKzg42K1rsIYBAAAAyCaSkpLkcDhUp04d5c6dW6tXr07et2/fPh09elQNGjRw65wkDAAAAICLrJIwhIWFqU2bNipZsqQuXbqk+fPna+3atVqxYoUCAwPVp08fDRo0SPnz51dAQIAGDBigBg0auHWHJImGAQAAAMiSzpw5o6efflrR0dEKDAxUjRo1tGLFCrVo0UKS9P7778vDw0OdO3eWw+FQq1at9PHHH7t9HZ7DgCyP5zAA2RfPYQCyr8z8HIbiLyy17NrHP+5g2bXNkDAAAAAALrLKlKSMknlbOwAAAACWI2EAAAAAXBEwGJAwAAAAADBFwwAAAADAFFOSAAAAABcsejYiYQAAAABgioQBAAAAcEHCYETCAAAAAMAUDQMAAAAAU0xJAgAAAFwwJcmIhAEAAACAKRIGAAAAwAUJgxEJAwAAAABTJAwAAACAKwIGAxIGAAAAAKZoGAAAAACYYkoSAAAA4IJFz0YkDAAAAABMkTAAAAAALkgYjEgYAAAAAJiiYQAAAABgiilJAAAAgAtmJBmRMAAAAAAwRcIAAAAAuGDRsxEJAwAAAABTJAwAAACACwIGIxIGAAAAAKZoGAAAAACYYkoSAAAA4IJFz0YkDAAAAABMkTAAAAAALggYjEgYAAAAAJiiYQAAAABgiilJAAAAgAsPD+YkuSJhAAAAAGCKhAEAAABwwaJnIxIGAAAAAKZIGAAAAAAXPLjNiIQBAAAAgCkaBgAAAACmmJIEAAAAuGBGkhENQzYQG3NGs6ZN1tZNv8mRkKAixUroxVdHqnylqlaXhn/pxL6divzxa505sl/xF87pkQEjVLb2/cn7f/psovb8ttLwnpBqddRh8NiMLhVpgO87Z9u6ZbPmzpqhPXt262xMjCZO+lBNHmpudVlIJ3zfyEpoGLK4y5cu6pX+vVS91r0aMX6KAvLmU/Txo/LzD7C6NKSB644EFShRRlUebKUfpoy+5TEh1euqRZ/Bya89c+XOqPKQxvi+c7arV6+qfMWKerRjJw19+UWry0E64/vO3Fj0bETDkMUtnj9TBQoG66WwUcljwUWKWVgR0lKpGveqVI17b3uMZ67c8g3Mn0EVIT3xfedsDR9spIYPNrK6DGQQvm9kJTQMWdzvv0Xonvvu17g3h2r3H5HKX6CQ2nboolbtOlldGjLI8b07NP3FLrL7+qtE5Zpq0KmXvP1ImLIrvm8AQEajYcjiTkWf0I/Lvlb7x3vo8R59tH/vbn36wXjlyp1LzVo/anV5SGch1euqXJ2GCigQrLiYaK1fPFPL3ntdXYZPkoeHp9XlIY3xfQNAxmBKkpHlDcPVq1cVGRmp/Pnzq0qVKoZ9CQkJWrhwoZ5++mnT9zscDjkcDsPYNUei8tjt6VJvZuNMSlK5ilX09PMDJEllK1TS0UNRWr5sEQ1DDlCxXpPkfy5QorQKFC+tWa/00vG9O1Syyj3WFYZ0wfcNALCCpc9h+Ouvv1S5cmU1atRI1atXV+PGjRUdHZ28Py4uTr17977tOcLDwxUYGGjYpn04Mb1LzzTyBRVQiVJlDGPFQ0or5swpiyqClQILFZG3X6DiTp+0uhRkAL5vAEgfNpt1W2ZkacPwyiuvqFq1ajpz5oz27dsnf39/NWzYUEePHk31OcLCwhQXF2fY+g4Yko5VZy6Vq9XSiaNHDGMnjx9VocJFLKoIVrp0LkZX4y/KNy+LYnMCvm8AQEawdErS+vXrtWrVKhUoUEAFChTQd999pxdeeEEPPvigfv75Z/n6+t7xHHa7XfZ/TD/Kc+VKepWc6bR/vIeGhfbSwrmf64GmLbR/z26t+G6xQoe8YXVpSAPXEq4q7sz///U4LuaUYo4ekN3XX16+/tq07AuVq/uAfAPz6cKZaP228DPlLVRUJavVsbBq3C2+75ztypV4HXP5g9mJE8e1b+8eBQYGKrhIUQsrQ3rg+87cWMNgZHM6nU6rLh4QEKBNmzapcuXKhvH+/ftr2bJlmj9/vpo0aaLExES3zrvvVM5pGCRp8/p1mjP9Q508cVSFg4upfZceOeouSasPnrG6hHRzfO8fWvzOsBTjlRu20ENPD9B3H4xSzNEoOa7EyzdvkEKq1Vb9jj3lG5jPgmrxb/F9p/RUnZJWl5Bhtmz+Xf369Ewx/sijHTRyTLgFFSE98X1L/nZLJ7rc1j2j1lh27W0jHrLs2mYsbRjuu+8+DRgwQE899VSKff3799e8efN08eJFGgbcVnZuGICcLic1DEBOQ8Nwa5mxYbD0m+rYsaO+/PLLW+6bMmWKunXrJgv7GQAAAORALHo2sjRhSC8kDDkLCQOQfZEwANlXZk4Yao+2LmHY+mbmSxgsfw4DAAAAkJmw6Nko87Z2AAAAACxHwwAAAADAFFOSAAAAABfMSDIiYQAAAABgioQBAAAAcMGiZyMSBgAAAACmSBgAAAAAFwQMRiQMAAAAAEzRMAAAAAAwxZQkAAAAwAWLno1IGAAAAACYImEAAAAAXBAwGJEwAAAAADBFwwAAAADAFA0DAAAA4MJms1m2uSM8PFz33nuv/P39VahQIXXo0EH79u0zHNOkSZMU1+jXr59b16FhAAAAALKgiIgIhYaGauPGjVq5cqWuX7+uli1bKj4+3nDcc889p+jo6ORt/Pjxbl2HRc8AAACACysXPTscDjkcDsOY3W6X3W5Pcezy5csNr2fNmqVChQopMjJSjRo1Sh738fFRcHDwXddEwgAAAABkEuHh4QoMDDRs4eHhqXpvXFycJCl//vyG8Xnz5qlAgQKqVq2awsLCdOXKFbdqImEAAAAAXFj54LawsDANGjTIMHardOGfkpKSNHDgQDVs2FDVqlVLHu/evbtCQkJUtGhR7dixQ6+88or27dunb775JtU10TAAAAAAmYTZ9KM7CQ0N1a5du/Trr78axp9//vnkf65evbqKFCmiZs2a6cCBAypbtmyqzs2UJAAAACAL69+/v77//nv9/PPPKl68+G2PrVevniQpKioq1ecnYQAAAABcZJUnPTudTg0YMEBLlizR2rVrVbp06Tu+Z/v27ZKkIkWKpPo6NAwAAABAFhQaGqr58+dr2bJl8vf316lTpyRJgYGB8vb21oEDBzR//ny1bdtWQUFB2rFjh15++WU1atRINWrUSPV1aBgAAAAAF1YuenbH1KlTJd18OJurmTNnqlevXsqTJ49WrVqlSZMmKT4+XiVKlFDnzp01fPhwt65DwwAAAABkQU6n87b7S5QooYiIiH99HRY9AwAAADBFwgAAAAC4yCpTkjIKCQMAAAAAUyQMAAAAgAsCBiMSBgAAAACmaBgAAAAAmGJKEgAAAOCCRc9GJAwAAAAATJEwAAAAAC4IGIxIGAAAAACYImEAAAAAXLCGwYiEAQAAAIApGgYAAAAAppiSBAAAALhgRpIRCQMAAAAAUyQMAAAAgAsPIgYDEgYAAAAApmgYAAAAAJhiShIAAADgghlJRiQMAAAAAEyRMAAAAAAueNKzEQkDAAAAAFMkDAAAAIALDwIGAxIGAAAAAKZoGAAAAACYYkoSAAAA4IJFz0YkDAAAAABMkTAAAAAALggYjLJlw9D9001Wl4AM1KdZaatLQAYaHDrR6hKQgUrMecPqEpCBGpYpYHUJyEh2qwtAajElCQAAAICpbJkwAAAAAHfLJuYkuSJhAAAAAGCKhAEAAABwwZOejUgYAAAAAJgiYQAAAABc8OA2IxIGAAAAAKZoGAAAAACYYkoSAAAA4IIZSUYkDAAAAABMkTAAAAAALjyIGAxIGAAAAACYomEAAAAAYIopSQAAAIALZiQZkTAAAAAAMEXCAAAAALjgSc9GJAwAAAAATJEwAAAAAC4IGIxIGAAAAACYomEAAAAAYIopSQAAAIALnvRsRMIAAAAAwBQJAwAAAOCCfMGIhAEAAACAKRoGAAAAAKaYkgQAAAC44EnPRiQMAAAAAEyRMAAAAAAuPAgYDNxOGLZu3aqdO3cmv162bJk6dOig1157TdeuXUvT4gAAAABYy+2GoW/fvvrrr78kSQcPHlTXrl3l4+Ojr7/+WsOGDUvzAgEAAICMZLPZLNsyI7cbhr/++ku1atWSJH399ddq1KiR5s+fr1mzZmnx4sVpXR8AAAAAC7ndMDidTiUlJUmSVq1apbZt20qSSpQoobNnz6ZtdQAAAAAs5fai57p162rMmDFq3ry5IiIiNHXqVEnSoUOHVLhw4TQvEAAAAMhImXRmkGXcThgmTZqkrVu3qn///nr99ddVrlw5SdKiRYt0//33p3mBAAAAAKzjdsJQo0YNw12S/jZhwgR5enqmSVEAAACAVTLr4mOruJ0wHDt2TMePH09+/fvvv2vgwIGaM2eOcufOnabFAQAAALCW2w1D9+7d9fPPP0uSTp06pRYtWuj333/X66+/rtGjR6d5gQAAAACs43bDsGvXLt13332SpIULF6patWpav3695s2bp1mzZqV1fQAAAECG8rBZt2VGbjcM169fl91ul3TztqqPPvqoJKlSpUqKjo5O2+oAAAAAWMrthqFq1ar65JNP9Msvv2jlypVq3bq1JOnkyZMKCgpK8wIBAACAjMSTno3cbhjeeecdTZs2TU2aNFG3bt1Us2ZNSdK3336bPFUJAAAAQPbgdsPQpEkTnT17VmfPntWMGTOSx59//nl98sknaVocAAAAkNFsFm7uCA8P17333it/f38VKlRIHTp00L59+wzHJCQkKDQ0VEFBQfLz81Pnzp11+vRpt67jdsMgSZ6ensqXL59hrFSpUipUqNDdnA4AAACAmyIiIhQaGqqNGzdq5cqVun79ulq2bKn4+PjkY15++WV99913+vrrrxUREaGTJ0+qU6dObl3H7Qe3STef6rxw4UIdPXpU165dM+zbunXr3ZwSAAAAgBuWL19ueD1r1iwVKlRIkZGRatSokeLi4vT5559r/vz5euihhyRJM2fOVOXKlbVx40bVr18/VddxO2H44IMP1Lt3bxUuXFjbtm3Tfffdp6CgIB08eFBt2rRx93QAAABApuJhs1m2ORwOXbx40bA5HI5U1R0XFydJyp8/vyQpMjJS169fV/PmzZOPqVSpkkqWLKkNGzak/vNw47OTJH388ceaPn26PvzwQ+XJk0fDhg3TypUr9eKLLyYXCQAAAMB94eHhCgwMNGzh4eF3fF9SUpIGDhyohg0bqlq1apJuPmQ5T548yps3r+HYwoUL69SpU6muye0pSUePHtX9998vSfL29talS5ckSU899ZTq16+vKVOmuHtKAAAAINOw8u6mYWFhGjRokGHs72eg3U5oaKh27dqlX3/9Nc1rcjthCA4O1rlz5yRJJUuW1MaNGyVJhw4dktPpTNvqAAAAgBzEbrcrICDAsN2pYejfv7++//57/fzzzypevHjyeHBwsK5du6YLFy4Yjj99+rSCg4NTXZPbDcNDDz2kb7/9VpLUu3dvvfzyy2rRooWeeOIJdezY0d3TAQAAALgLTqdT/fv315IlS7RmzRqVLl3asL9OnTrKnTu3Vq9enTy2b98+HT16VA0aNEj1ddyekjR9+nQlJSVJUvI9XdevX69HH31Uffv2dfd0AAAAQKaSWZ+4/E+hoaGaP3++li1bJn9//+R1CYGBgfL29lZgYKD69OmjQYMGKX/+/AoICNCAAQPUoEGDVN8hSbqLhsHDw0MeHv8fTHTt2lVdu3Z19zQAAAAA/oWpU6dKuvlgZVczZ85Ur169JEnvv/++PDw81LlzZzkcDrVq1Uoff/yxW9dJVcOwY8eOVJ+wRo0abhUAAAAAZCZZJGBI1fphLy8vffTRR/roo4/u+jqpahhq1aolm812x6JsNpsSExPvuhgAAAAAmUuqGoZDhw6ldx0AAAAAMqFUNQwhISHpXQcAAACQKXhklTlJGSTVi54jIyM1ZMgQLVu2TAEBAYZ9cXFx6tChgyZNmqSaNWumeZG4qXfDkmpaqaBKBfnIcSNJO47H6YPVB3Qk9qrhuOrFAhTatIyqFQtQotOpv05dVv/5f8hxI8miynG3Tuzbqcgfv9aZI/sVf+GcHhkwQmVr35+8/6fPJmrPbysN7wmpVkcdBo/N6FKRBp57/AE999iDCimaX5K05+ApjZ3+o3767U9JUuEgf40d2FEP1a8kf1+7/jp8RuM/X6Glq7dbWDXu1oE/t2vtsgU6cXCfLp6PVa9hb6vafQ9KkhJv3NCPX36qvds2KvZ0tLx9fFW+el217dFXgfkLWFw50sLsGdMVsWaVjhw+KLvdS9Vr1tILLw5WSKnSd34zkMFS3TC8++67euihh1I0C9LNWze1aNFCEyZM0BdffJGmBeL/1S6ZV19vPqHd0Rfl6WFT/6Zl9VH3Wnrsk01KuH6zGaheLEBTutfUzN+OaPyKv5SY5FSFwn5K4qF6WdJ1R4IKlCijKg+20g9TRt/ymJDqddWiz+Dk1565cmdUeUhjJ05f0BsfLlPU0RjZZFOPdvX09fvPq37Xcdpz8JQ+e+tp5fX31uMDp+nshct6ok1dffHOM2r45Hj9se+41eXDTdcSElS0VFnd91BbzZ4w3LjPkaATh/ar+WM9VTSknK7GX9LSGR9o5rgwDRz/qUUVIy1ti9yizl26qXLVakpMTNQnUyZp4AvPav7i7+Tt7WN1eTkeAYNRqhuGTZs26dVXXzXd365dO3322WdpUhRubcCXxrtVjfh2j1YPfkCVi/hr29E4SdLgluW0YPNxzVp/NPm4fyYQyDpK1bhXpWrce9tjPHPllm9g/gyqCOnpv+t2GV6P/Og7Pff4A7qvRmntOXhK9WuW0YtjF2jL7iOSpHc+W6EBTz6ke6qUoGHIgirXrq/KtW99H3RvXz/1ffM9w1jHZwfqg1f76nzMaeUrWDgjSkQ6mvTRdMPr4aPGqm2zB7T3zz91T526FlUF3FqqG4YTJ07I39/fdL+fn5+io6PTpCikjp/95td38eoNSVI+n9yqXjxQP+46rRm9aqt4Pm8djr2ij38+qO3H4qwsFeno+N4dmv5iF9l9/VWick016NRL3n4pk0BkLR4eNnVuUVu+3nm0acfNG09s/OOgHmtZR8t/2a0Ll67qsZa15WXPpXVb9ltcLTJCwpV42Ww2efv6WV0K0sHlS5ckSQGBgRZXAinrPLgto6S6YShYsKD27duX4pHTf9u7d68KFGBeZUaxSRrSspy2H72gAzHxkqRi+bwlSc83Kq1Jq6L01+nLerh6sKb2qKUu037XsXMkDdlNSPW6KlenoQIKBCsuJlrrF8/UsvdeV5fhk+Th4Wl1ebgLVcsV1drZg+WVJ5cuX3XoicGfau/Bm0/u7DFshua+84xORozX9euJupJwTU8M+lQHj521uGqkt+vXHPrhi09Uq2Ezefn4Wl0O0lhSUpImTRynGrVqq2y58laXA6SQ6oahefPmevvtt9W6desU+5xOp95++201b97c7QL27NmjjRs3qkGDBqpUqZL27t2ryZMny+FwqEePHnrooYdu+36HwyGHw2EYS7pxTR658rhdS1byapsKKlvIV31mbUse8/hfM/zN1pP67o+bv2DsOxWl+0rnU/taRTRlzUErSkU6qlivSfI/FyhRWgWKl9asV3rp+N4dKlnlHusKw1376/Bp1esarkA/b3Vsfo8+Hf2UWj47WXsPntKI0EeU199bbfp+oNgL8WrXpIa+GP+Mmj8zSbujTlpdOtJJ4o0bmvveCMnpVOfnB9/5DchyJo57SwcP7Ne0GawDRebkkdoDhw8frp07d6pevXpauHCh/vjjD/3xxx/66quvVK9ePe3atUuvv/66Wxdfvny5atWqpSFDhuiee+7R8uXL1ahRI0VFRenIkSNq2bKl1qxZc9tzhIeHKzAw0LCdWjffrTqymmGty+uB8kHqO3e7zlz6/2bp7OVrkqSDZ+MNxx86G6/gAHuG1ghrBBYqIm+/QMWd5pfHrOr6jUQdPHZW2/Yc05sffqudf51QaLcmKl28gP7TtbH6jvxCa3//Szv/OqGx03/U1j+Pqu8TjawuG+nk72bhfMxpPf/me6QL2dDEcWP02y8R+mj6LBUqHGx1OfgfDwu3zCjVdZUtW1arVq1SfHy8unbtqtq1a6t27drq1q2brly5opUrV6pcuXJuXXz06NEaOnSoYmNjNXPmTHXv3l3PPfecVq5cqdWrV2vo0KEaN27cbc8RFhamuLg4wxbcqLtbdWQlw1qXV9OKBdXvi+06eSHBsO/khQSduehQqSDj3RVKBvkoOs6YwiB7unQuRlfjL8o3L4ugswsPm032PLnk43UzNf3nHc8SE53cLzyb+rtZiIk+rr5vvi9ff+a2ZydOp1MTx41RxM+rNGXaDBUtVtzqkgBTqZ6SJEl169bVrl27tH37du3fv19Op1MVKlRQrVq17uriu3fv1pw5cyRJXbp00VNPPaXHHnssef+TTz6pmTNn3vYcdrtddrvxr+fZdTrSq20qqHW1Qhr01S5dcSQqyPfmz3nZcSP5GQtzNhxVv8al9dfpy9p36rLa1QxWqSAfvbJo1+1OjUzqWsJVxZ35/7QgLuaUYo4ekN3XX16+/tq07AuVq/uAfAPz6cKZaP228DPlLVRUJavVsbBq3K3RAx7Vit9261j0efn7eumJNnXVqG55tXvhY+07fEpRR89oyvBuCntviWLj4vVo0xpqVr+iOr30idWl4y44rl7R2VMnkl+fOx2tE4f2y8cvQAH5gjRn4hs6fugv9Ql7R0lJibp4PlaS5OMXoFy5uX1yVjdx3Fv66ccf9M77U+Tj46vYszGSJF8/f3l5eVlcHVj0bORWw/C3WrVq3XWT8E9/fyEeHh7y8vJSoMvdAfz9/RUXx919/vZ43WKSpE97Guemj1y2R9/tuLlm4cvfj8uey0ODWpRToHdu/XX6skLn/aHj5xNSnA+Z35nDf2nxO8OSX/+yYJokqXLDFnro6QE6e+yQ9vy2Uo4r8fLNG6SQarVVv2NP5cqdPZvm7K5gfj99/tbTCi4QoLjLCdq1/4TavfCx1mzaK0nqMGCqxrzYXosm95Wfj10HjsXo2TfnasWvf1pcOe7GsQP79MnIl5Jffzt7iiSpbpPWatmlt3Zv+U2S9N6QZwzv6zdysspVY41SVvfN1wskSaHP9TSMDx/5th5+tKMVJQGmbE6ndU/0qlmzpt55553khdS7du1SpUqVlCvXzT7ml19+Uc+ePXXwoHuLdeu89XOa14rMq08znoqZkwwOnWh1CchAC+e8YXUJyEANy3C3xZwkv2/mvZvfi0v3WnbtDzpUsuzaZu4qYUgr//nPf5SYmJj8ulq1aob9P/744x3vkgQAAACkJQ9mJBlY2jD069fvtvvHjh2bQZUAAAAAuBVLGwYAAAAgsyFhMLqr273+8ssv6tGjhxo0aKATJ27e4WHu3Ln69ddf07Q4AAAAANZyu2FYvHixWrVqJW9vb23bti35KctxcXFMIQIAAECWZ7PZLNsyI7cbhjFjxuiTTz7Rp59+qtwu94Fu2LChtm7dmqbFAQAAALCW2w3Dvn371KhRoxTjgYGBunDhQlrUBAAAACCTcLthCA4OVlRUVIrxX3/9VWXKlEmTogAAAACreNis2zIjtxuG5557Ti+99JI2bdokm82mkydPat68eRoyZIj+85//pEeNAAAAACzi9m1VX331VSUlJalZs2a6cuWKGjVqJLvdriFDhmjAgAHpUSMAAACQYTLp2mPLuN0w2Gw2vf766xo6dKiioqJ0+fJlValSRX5+fulRHwAAAAAL3fWD2/LkyaMqVaqkZS0AAAAAMhm3G4amTZve9h6xa9as+VcFAQAAAFbyYE6SgdsNQ61atQyvr1+/ru3bt2vXrl3q2bNnWtUFAAAAIBNwu2F4//33bzk+cuRIXb58+V8XBAAAAFjJ7duIZnNp9nn06NFDM2bMSKvTAQAAAMgE7nrR8z9t2LBBXl5eaXU6AAAAwBIsYTByu2Ho1KmT4bXT6VR0dLS2bNmiN954I80KAwAAAGA9txuGwMBAw2sPDw9VrFhRo0ePVsuWLdOsMAAAAADWc6thSExMVO/evVW9enXly5cvvWoCAAAALMNtVY3cWvTs6empli1b6sKFC+lUDgAAAIDMxO27JFWrVk0HDx5Mj1oAAAAAy9ls1m2ZkdsNw5gxYzRkyBB9//33io6O1sWLFw0bAAAAgOwj1WsYRo8ercGDB6tt27aSpEcffVQ2lzbI6XTKZrMpMTEx7asEAAAAYIlUNwyjRo1Sv3799PPPP6dnPQAAAIClPDLp1CCrpLphcDqdkqTGjRunWzEAAAAAMhe3bqtqy6wrMQAAAIA0wm1VjdxqGCpUqHDHpuHcuXP/qiAAAAAAmYdbDcOoUaNSPOkZAAAAyE4IGIzcahi6du2qQoUKpVctAAAAADKZVD+HgfULAAAAQM7j9l2SAAAAgOyM26oapbphSEpKSs86AAAAAGRCbq1hAAAAALI7m4gYXKV6DQMAAACAnIeGAQAAAIAppiQBAAAALlj0bETCAAAAAMAUCQMAAADggoTBiIQBAAAAgCkSBgAAAMCFzUbE4IqEAQAAAIApGgYAAAAAppiSBAAAALhg0bMRCQMAAAAAUyQMAAAAgAvWPBuRMAAAAAAwRcMAAAAAwBRTkgAAAAAXHsxJMiBhAAAAAGCKhAEAAABwwW1VjUgYAAAAAJgiYQAAAABcsITBiIQBAAAAgCkaBgAAAACmmJIEAAAAuPAQc5JcZcuGYf5z9awuARkotydBWU7y6Jp3rS4BGWjkT/utLgEZqGGZAlaXAGQp69at04QJExQZGano6GgtWbJEHTp0SN7fq1cvzZ492/CeVq1aafny5W5dJ1s2DAAAAMDdyiqLnuPj41WzZk0988wz6tSp0y2Pad26tWbOnJn82m63u30dGgYAAAAgC2rTpo3atGlz22PsdruCg4P/1XWYywEAAABkEg6HQxcvXjRsDofjrs+3du1aFSpUSBUrVtR//vMfxcbGun0OGgYAAADAhYfNui08PFyBgYGGLTw8/K5+jtatW2vOnDlavXq13nnnHUVERKhNmzZKTEx06zxMSQIAAAAyibCwMA0aNMgwdjfrDiSpa9euyf9cvXp11ahRQ2XLltXatWvVrFmzVJ+HhgEAAABw4WHhqme73X7XDcKdlClTRgUKFFBUVJRbDQNTkgAAAIAc4Pjx44qNjVWRIkXceh8JAwAAAJAFXb58WVFRUcmvDx06pO3btyt//vzKnz+/Ro0apc6dOys4OFgHDhzQsGHDVK5cObVq1cqt69AwAAAAAC6yynMYtmzZoqZNmya//nvtQ8+ePTV16lTt2LFDs2fP1oULF1S0aFG1bNlSb731lttTnmgYAAAAgCyoSZMmcjqdpvtXrFiRJtehYQAAAABcWLnoOTNi0TMAAAAAUyQMAAAAgAsCBiMSBgAAAACmaBgAAAAAmGJKEgAAAOCCv6gb8XkAAAAAMEXCAAAAALiwserZgIQBAAAAgCkaBgAAAACmmJIEAAAAuGBCkhEJAwAAAABTJAwAAACACw8WPRuQMAAAAAAwRcIAAAAAuCBfMCJhAAAAAGCKhgEAAACAKaYkAQAAAC5Y82xEwgAAAADAFAkDAAAA4MJGxGBAwgAAAADAFA0DAAAAAFNMSQIAAABc8Bd1Iz4PAAAAAKZIGAAAAAAXLHo2ImEAAAAAYIqEAQAAAHBBvmBEwgAAAADAFA0DAAAAAFNMSQIAAABcsOjZiIQBAAAAgCkSBgAAAMAFf1E34vMAAAAAYIqGAQAAAIAppiQBAAAALlj0bETCAAAAAMAUCQMAAADggnzBiIQBAAAAgCkSBgAAAMAFSxiMSBgAAAAAmKJhAAAAAGCKKUkAAACACw+WPRuQMAAAAAAwRcIAAAAAuGDRsxEJAwAAAABTNAwAAAAATDElKRuIjTmjWdMma+um3+RISFCRYiX04qsjVb5SVatLQxr74vOpmjfzE8NY8ZKl9On8ZRZVhIz05ZzP9dnHk9XpiScV+vIrVpeDf6lN5QKqXTxARfztupbo1IGzV7RoxymdvnQt+ZhcHjZ1qRWs+0oGKpeHTbtPXda8yJO66Ei0sHKkhdkzpitizSodOXxQdruXqtespRdeHKyQUqWtLg2SbCx6NqBhyOIuX7qoV/r3UvVa92rE+CkKyJtP0cePys8/wOrSkE5CSpfV2EnTk197enpaWA0yyt4/d+n7JV+rTLkKVpeCNFKxoK9+3n9Oh89dlYeHTZ2qF9agxqX0xo/7dS3RKUnqek+wqhfx1yfrj+nq9UR1r11ULzxQUuNWH7K4evxb2yK3qHOXbqpctZoSExP1yZRJGvjCs5q/+Dt5e/tYXR5gkOkaBqfTKRsrTVJt8fyZKlAwWC+FjUoeCy5SzMKKkN48PXMpf1ABq8tABrp65YrGjgjToLCRmjdz+p3fgCxh0rojhtczfj+uSR0qKyS/t/bHXJF3bg89UDqfPt14XHvPxEuSZv5+XGPaVlCZIG8djL1qRdlII5M+Mv67PHzUWLVt9oD2/vmn7qlT16Kq8Dd+FTXKdGsY7Ha79uzZY3UZWcbvv0WoXKUqGvfmUD3V/iG91KerVnz3jdVlIR2dOH5ET7Zvrt6Pt9U7o8J05lS01SUhnU2e+LbqN3xQde6rb3UpSEc+uW+mhfHXbk43CsnnrVyeHvrz9OXkY05duqbY+GsqG8RfoLOby5cuSZICAgMtrgRIybKEYdCgQbccT0xM1Lhx4xQUFCRJeu+99257HofDIYfDYRi75khUHrs9bQrN5E5Fn9CPy75W+8d76PEefbR/7259+sF45cqdS81aP2p1eUhjFatU1+DX3lLxkqV0LjZG82ZO09DQ3po6d7F8fHytLg/pYM3KHxW1b48+nvGl1aUgHdkkPXFPsPbHxOtk3M3/pwV45dL1xCRdvZ5kOPZiwg0FeGW6CQL4F5KSkjRp4jjVqFVbZcuVt7ociAe3/ZNl/8WZNGmSatasqbx58xrGnU6n9uzZI19f31RNTQoPD9eoUaMMY6GDX9OAIa+nZbmZljMpSeUqVtHTzw+QJJWtUElHD0Vp+bJFNAzZ0L0NHkj+59LlKqhilerq+Vgb/bJmhVo90snCypAezpw+pY/ee0fjP5ieY/4IklM9WaeIigV66Z3VB60uBRaYOO4tHTywX9NmfGF1KcAtWdYwjB07VtOnT9e7776rhx56KHk8d+7cmjVrlqpUqZKq84SFhaVIK46czzl3j8gXVEAlSpUxjBUPKa3161ZbVBEykp9/gIqVCNHJ48esLgXp4K+9f+rC+XPq1+uJ5LGkxETt2B6ppYsWaPm6LSx6zwa61y6iGkUDNH7NQZ2/eiN5/GLCDeX29JB3bg9DyhDglUsXE27c6lTIgiaOG6PffonQ1M/mqFDhYKvLAW7Jsobh1VdfVbNmzdSjRw+1a9dO4eHhyp07t9vnsdvtsv/jL295rlxJqzIzvcrVaunEUePCuZPHj6pQ4SIWVYSMdPXKFUWfOKZmrR62uhSkg9p16+mzeYsNYxPGvKkSIaXV9aneNAvZQPfaRXRPsQBN+PmQzsZfN+w7cv6qbiQmqXJhP209flGSVNg/j4J88+hAbM75/1x25XQ69e47byvi51X6+NNZKlqsuNUlwQWLno0sXfR87733KjIyUjExMapbt6527drFHZLc1P7xHtr3504tnPu5Th4/qoiVP2rFd4vVtuMTd34zspxPp7yrHdu26HT0Cf25c7veeu1leXh6qnHzNlaXhnTg4+ur0mXLGzYvL28FBAaqdFnmOWd1T9YpovohefXpxmNKuJGkAK9cCvDKpdyeN/8/ePV6kn49dF5P1ApWxUK+Csnnpd73FVfU2SvcISkbmDjuLa3473caNXaCfHx8FXs2RrFnY5SQkGB1aUAKlq+a8vPz0+zZs7VgwQI1b95ciYk5ZzpRWihfuapeG/Ou5kz/UF/Nma7CwcX0bP+hatKirdWlIR2cjTmtd0a+qosXLygwbz5VrXGP3p82V3nz5be6NABualru5s09hj1knFY6Y9NxrT98QZK0YNspJTmlF+4voVyeHtp96pK+iOTOaNnBN18vkCSFPtfTMD585Nt6+NGOVpQEF/z92sjmdDqdVhfxt+PHjysyMlLNmzeXr+/d3/Fl3ymi2pwkt2emuzsw0lGeXPxXPCcZ+dN+q0tABhr/SGWrS0AGyu+beadV/rQnxrJrt6xc0LJrm7E8YXBVvHhxFS/OHD4AAAAgs8hUDQMAAABgNRvPYTBgLgcAAAAAUyQMAAAAgAsPAgYDEgYAAAAApkgYAAAAABesYTAiYQAAAABgioYBAAAAgCmmJAEAAAAueNKzEQkDAAAAAFMkDAAAAIALFj0bkTAAAAAAMEXDAAAAAMAUDQMAAADgwsNm3eaOdevWqV27dipatKhsNpuWLl1q2O90OvXmm2+qSJEi8vb2VvPmzbV//373Pw+33wEAAADAcvHx8apZs6Y++uijW+4fP368PvjgA33yySfatGmTfH191apVKyUkJLh1HRY9AwAAAC6yyqLnNm3aqE2bNrfc53Q6NWnSJA0fPlzt27eXJM2ZM0eFCxfW0qVL1bVr11Rfh4QBAAAAyCQcDocuXrxo2BwOh9vnOXTokE6dOqXmzZsnjwUGBqpevXrasGGDW+eiYQAAAAAyifDwcAUGBhq28PBwt89z6tQpSVLhwoUN44ULF07el1pMSQIAAABcWPmk57CwMA0aNMgwZrfbLarmJhoGAAAAIJOw2+1p0iAEBwdLkk6fPq0iRYokj58+fVq1atVy61xMSQIAAABc2Czc0krp0qUVHBys1atXJ49dvHhRmzZtUoMGDdw6FwkDAAAAkAVdvnxZUVFRya8PHTqk7du3K3/+/CpZsqQGDhyoMWPGqHz58ipdurTeeOMNFS1aVB06dHDrOjQMAAAAgAsPKxcxuGHLli1q2rRp8uu/1z707NlTs2bN0rBhwxQfH6/nn39eFy5c0AMPPKDly5fLy8vLrevYnE6nM00rzwT2nbpidQnIQLk9mVmXk+TJlTX+I460MfIn959Iiqxr/COVrS4BGSi/r6fVJZjaEHXBsms3KJfXsmub4TctAAAAAKaYkgQAAAC4IMs2ImEAAAAAYIqEAQAAAHBFxGBAwgAAAADAFA0DAAAAAFNMSQIAAABc2JiTZEDCAAAAAMAUCQMAAADgIos86DnDkDAAAAAAMEXCAAAAALggYDAiYQAAAABgioYBAAAAgCmmJAEAAACumJNkQMIAAAAAwBQJAwAAAOCCB7cZkTAAAAAAMEXDAAAAAMAUU5IAAAAAFzzp2YiEAQAAAIApEgYAAADABQGDEQkDAAAAAFMkDAAAAIArIgYDEgYAAAAApmgYAAAAAJhiShIAAADggic9G5EwAAAAADBFwgAAAAC44MFtRiQMAAAAAEzRMAAAAAAwxZQkAAAAwAUzkoxIGAAAAACYypYJQ0gBH6tLAJBOLly5bnUJyEBDG5exugQAORERgwEJAwAAAABT2TJhAAAAAO4WD24zImEAAAAAYIqGAQAAAIAppiQBAAAALnjSsxEJAwAAAABTJAwAAACACwIGIxIGAAAAAKZoGAAAAACYYkoSAAAA4Io5SQYkDAAAAABMkTAAAAAALnjSsxEJAwAAAABTJAwAAACACx7cZkTCAAAAAMAUDQMAAAAAU0xJAgAAAFwwI8mIhAEAAACAKRIGAAAAwBURgwEJAwAAAABTNAwAAAAATDElCQAAAHDBk56NSBgAAAAAmCJhAAAAAFzwpGcjEgYAAAAApkgYAAAAABcEDEYkDAAAAABM0TAAAAAAMMWUJAAAAMAVc5IMSBgAAAAAmCJhAAAAAFzw4DYjEgYAAAAApmgYAAAAAJhiShIAAADggic9G5EwAAAAADBFwgAAAAC4IGAwImEAAAAAYIqGAQAAAMiCRo4cKZvNZtgqVaqU5tdhShIAAADgKgvNSapatapWrVqV/DpXrrT/9Z6GAQAAAMiicuXKpeDg4PS9RrqeHQAAAMhirHzSs8PhkMPhMIzZ7XbZ7fZbHr9//34VLVpUXl5eatCggcLDw1WyZMk0rYk1DAAAAEAmER4ersDAQMMWHh5+y2Pr1aunWbNmafny5Zo6daoOHTqkBx98UJcuXUrTmmxOp9OZpmfMBBJuWF0BgPRy4cp1q0tABorj+85RCvrf+i+oyJ7y+3paXYKpQ2cTLLt2UX+bWwmDqwsXLigkJETvvfee+vTpk2Y1MSUJAAAAyCRS2xzcSt68eVWhQgVFRUWlaU1MSQIAAACygcuXL+vAgQMqUqRImp6XhgEAAABwYbNwc8eQIUMUERGhw4cPa/369erYsaM8PT3VrVu3u/zJb40pSQAAAEAWdPz4cXXr1k2xsbEqWLCgHnjgAW3cuFEFCxZM0+vQMAAAAACussiD2xYsWJAh12FKEgAAAABTNAwAAAAATDElCQAAAHBh5ZOeMyMSBgAAAACmSBgAAAAAFzYCBgMSBgAAAACmSBgAAAAAFwQMRjQM2cSC+fM0e+bnOns2RhUqVtKrr72h6jVqWF0W0gnfd86wdNECLVv8lU5Fn5QklSpTTj379FP9hg9aXBnSS2zMGc2aNllbN/0mR0KCihQroRdfHanylapaXRrS2OwZ0xWxZpWOHD4ou91L1WvW0gsvDlZIqdJWlwakwJSkbGD5j//VxPHh6vtCqBZ8vUQVK1bSf/r2UWxsrNWlIR3wfeccBQsFq2//l/XpnIWaPvsr1a57n14fMkCHDkRZXRrSweVLF/VK/17K5ZlLI8ZP0ZQ5i/VM6CD5+QdYXRrSwbbILercpZs+nf2lJk/9TDdu3NDAF57V1atXrC4NSMHmdDqdVheR1hJuWF1Bxnqy6+OqWq26Xhv+piQpKSlJLZs1VrfuT6nPc89bXB3SWk7/vi9cuW51CZZ6pNn9+s+Lg/Vw+85Wl5Ih4nLQ9z172mTt2fmHxk2ZYXUplinob7e6BMucP39ObZs9oI8/naN76tS1upwMkd/X0+oSTB0/77Ds2sXzZb5/D0gYsrjr165pz5+7Vb/B/cljHh4eql//fu34Y5uFlSE98H3nXImJiVr903+VcPWqqlavZXU5SAe//xahcpWqaNybQ/VU+4f0Up+uWvHdN1aXhQxy+dIlSVJAYKDFlQApZao1DPHx8Vq4cKGioqJUpEgRdevWTUFBQbd9j8PhkMNh7AKdnnbZ7ZmvO0sP5y+cV2JiYorPKSgoSIcOHbSoKqQXvu+c50DUXwp95kldu3ZN3t4+GjNhskqVKWt1WUgHp6JP6MdlX6v94z30eI8+2r93tz79YLxy5c6lZq0ftbo8pKOkpCRNmjhONWrVVtly5a0uB5JY9mxkacJQpUoVnTt3TpJ07NgxVatWTS+//LJWrlypESNGqEqVKjp06NBtzxEeHq7AwEDDNuGd8IwoHwDSXcmQ0vps3mJNnTlf7Tt30diRr+vwwQNWl4V04ExKUtnylfT08wNUtkIltX60s1o+0lHLly2yujSks4nj3tLBA/v1VvhEq0sBbsnShmHv3r26cePmgoOwsDAVLVpUR44c0e+//64jR46oRo0aev311297jrCwMMXFxRm2oa+EZUT5mUK+vPnk6emZYsFrbGysChQoYFFVSC983zlP7ty5VbxESVWsXFXP939Z5cpX1KIFX1hdFtJBvqACKlGqjGGseEhpxZw5ZVFFyAgTx43Rb79E6KPps1SocLDV5QC3lGnWMGzYsEEjR45U4P/m7vn5+WnUqFH69ddfb/s+u92ugIAAw5ZTpiNJUu48eVS5SlVt2rgheSwpKUmbNm1QjZr3WFgZ0gPfN5KcSbp+7ZrVZSAdVK5WSyeOHjGMnTx+VIUKF7GoIqQnp9OpiePGKOLnVZoybYaKFitudUlwYbNZt2VGljcMtv99MgkJCSpSxPgfxWLFiikmJsaKsrKUp3r21jeLFurbpUt08MABjRk9UlevXlWHjp2sLg3pgO8755g+5X39sXWLok+e0IGovzR9yvvaHrlZzds8bHVpSAftH++hfX/u1MK5n+vk8aOKWPmjVny3WG07PmF1aUgHE8e9pRX//U6jxk6Qj4+vYs/GKPZsjBISEqwuDUjB8kXPzZo1U65cuXTx4kXt27dP1apVS9535MiROy56htS6TVudP3dOH0/5QGfPxqhipcr6eNpnCmKKSrbE951znD9/TmNHvqbYszHy9fNX2XIVNOHDabq33v13fjOynPKVq+q1Me9qzvQP9dWc6SocXEzP9h+qJi3aWl0a0sE3Xy+QJIU+19MwPnzk23r40Y5WlAQXmfQP/Zax9DkMo0aNMryuX7++WrVqlfx66NChOn78uL788ku3zpvTnsMA5CQ5/TkMOU1Oeg4DcvZzGHKizPwchpMXrJv6WTRvHsuubYYHtwHIUmgYchYahpyFhiFnycwNQ3ScdQ1DkcDM1zBYvoYBAAAAQOZFwwAAAADAlOWLngEAAIDMxMayZwMSBgAAAACmSBgAAAAAVwQMBiQMAAAAAEzRMAAAAAAwxZQkAAAAwAUzkoxIGAAAAACYImEAAAAAXNiIGAxIGAAAAACYImEAAAAAXPDgNiMSBgAAAACmaBgAAAAAmGJKEgAAAOCKGUkGJAwAAAAATJEwAAAAAC4IGIxIGAAAAACYomEAAAAAYIopSQAAAIALnvRsRMIAAAAAwBQJAwAAAOCCJz0bkTAAAAAAMEXCAAAAALhgDYMRCQMAAAAAUzQMAAAAAEzRMAAAAAAwRcMAAAAAwBSLngEAAAAXLHo2ImEAAAAAYIqGAQAAAIAppiQBAAAALnjSsxEJAwAAAABTJAwAAACACxY9G5EwAAAAADBFwgAAAAC4IGAwImEAAAAAYIqGAQAAAIAppiQBAAAArpiTZEDCAAAAAMAUCQMAAADggge3GZEwAAAAADBFwwAAAADAFFOSAAAAABc86dmIhAEAAACAKRIGAAAAwAUBgxEJAwAAAABTNAwAAAAATDElCQAAAHDFnCQDEgYAAAAApkgYAAAAABc86dmIhAEAAADIoj766COVKlVKXl5eqlevnn7//fc0vwYNAwAAAODCZrNuc8dXX32lQYMGacSIEdq6datq1qypVq1a6cyZM2n7eTidTmeanjETSLhhdQUA0suFK9etLgEZKI7vO0cp6G+3ugRkoPy+nlaXYMrK3yW93FgwUK9ePd17772aMmWKJCkpKUklSpTQgAED9Oqrr6ZZTSQMAAAAQCbhcDh08eJFw+ZwOFIcd+3aNUVGRqp58+bJYx4eHmrevLk2bNiQpjVly0XP7nRm2YXD4VB4eLjCwsJkt/MXmuwuJ3/fwQG5rS4hw/F95yw5+fvOifi+Mycrf5ccOSZco0aNMoyNGDFCI0eONIydPXtWiYmJKly4sGG8cOHC2rt3b5rWlC2nJOVEFy9eVGBgoOLi4hQQEGB1OUhnfN85C993zsL3nbPwfeOfHA5HikTBbrenaChPnjypYsWKaf369WrQoEHy+LBhwxQREaFNmzalWU058G/xAAAAQOZ0q+bgVgoUKCBPT0+dPn3aMH769GkFBwenaU2sYQAAAACymDx58qhOnTpavXp18lhSUpJWr15tSBzSAgkDAAAAkAUNGjRIPXv2VN26dXXfffdp0qRJio+PV+/evdP0OjQM2YTdbteIESNYMJVD8H3nLHzfOQvfd87C941/44knnlBMTIzefPNNnTp1SrVq1dLy5ctTLIT+t1j0DAAAAMAUaxgAAAAAmKJhAAAAAGCKhgEAAACAKRoGAAAAAKZoGLK4devWqV27dipatKhsNpuWLl1qdUlIR+Hh4br33nvl7++vQoUKqUOHDtq3b5/VZSGdTJ06VTVq1FBAQIACAgLUoEED/fjjj1aXhQwybtw42Ww2DRw40OpSkA5Gjhwpm81m2CpVqmR1WcAt0TBkcfHx8apZs6Y++ugjq0tBBoiIiFBoaKg2btyolStX6vr162rZsqXi4+OtLg3poHjx4ho3bpwiIyO1ZcsWPfTQQ2rfvr12795tdWlIZ5s3b9a0adNUo0YNq0tBOqpataqio6OTt19//dXqkoBb4jkMWVybNm3Upk0bq8tABlm+fLnh9axZs1SoUCFFRkaqUaNGFlWF9NKuXTvD67fffltTp07Vxo0bVbVqVYuqQnq7fPmynnzySX366acaM2aM1eUgHeXKlUvBwcFWlwHcEQkDkIXFxcVJkvLnz29xJUhviYmJWrBggeLj49WgQQOry0E6Cg0N1cMPP6zmzZtbXQrS2f79+1W0aFGVKVNGTz75pI4ePWp1ScAtkTAAWVRSUpIGDhyohg0bqlq1alaXg3Syc+dONWjQQAkJCfLz89OSJUtUpUoVq8tCOlmwYIG2bt2qzZs3W10K0lm9evU0a9YsVaxYUdHR0Ro1apQefPBB7dq1S/7+/laXBxjQMABZVGhoqHbt2sWc12yuYsWK2r59u+Li4rRo0SL17NlTERERNA3Z0LFjx/TSSy9p5cqV8vLysrocpDPX6cQ1atRQvXr1FBISooULF6pPnz4WVgakRMMAZEH9+/fX999/r3Xr1ql48eJWl4N0lCdPHpUrV06SVKdOHW3evFmTJ0/WtGnTLK4MaS0yMlJnzpxR7dq1k8cSExO1bt06TZkyRQ6HQ56enhZWiPSUN29eVahQQVFRUVaXAqRAwwBkIU6nUwMGDNCSJUu0du1alS5d2uqSkMGSkpLkcDisLgPpoFmzZtq5c6dhrHfv3qpUqZJeeeUVmoVs7vLlyzpw4ICeeuopq0sBUqBhyOIuX75s+GvEoUOHtH37duXPn18lS5a0sDKkh9DQUM2fP1/Lli2Tv7+/Tp06JUkKDAyUt7e3xdUhrYWFhalNmzYqWbKkLl26pPnz52vt2rVasWKF1aUhHfj7+6dYj+Tr66ugoCDWKWVDQ4YMUbt27RQSEqKTJ09qxIgR8vT0VLdu3awuDUiBhiGL27Jli5o2bZr8etCgQZKknj17atasWRZVhfQydepUSVKTJk0M4zNnzlSvXr0yviCkqzNnzujpp59WdHS0AgMDVaNGDa1YsUItWrSwujQA/9Lx48fVrVs3xcbGqmDBgnrggQe0ceNGFSxY0OrSgBRsTqfTaXURAAAAADInnsMAAAAAwBQNAwAAAABTNAwAAAAATNEwAAAAADBFwwAAAADAFA0DAAAAAFM0DAAAAABM0TAAAAAAMEXDAAD/Uq9evdShQ4fk102aNNHAgQMzvI61a9fKZrPpwoULmeI8AIDsgYYBQLbUq1cv2Ww22Ww25cmTR+XKldPo0aN148aNdL/2N998o7feeitVx1rxy/m2bdv0+OOPq3DhwvLy8lL58uX13HPP6a+//sqwGgAAWQcNA4Bsq3Xr1oqOjtb+/fs1ePBgjRw5UhMmTLjlsdeuXUuz6+bPn1/+/v5pdr609P3336t+/fpyOByaN2+e9uzZoy+++EKBgYF64403rC4PAJAJ0TAAyLbsdruCg4MVEhKi//znP2revLm+/fZbSf8/jejtt99W0aJFVbFiRUnSsWPH1KVLF+XNm1f58+dX+/btdfjw4eRzJiYmatCgQcqbN6+CgoI0bNgwOZ1Ow3X/OSXJ4XDolVdeUYkSJWS321WuXDl9/vnnOnz4sJo2bSpJypcvn2w2m3r16iVJSkpKUnh4uEqXLi1vb2/VrFlTixYtMlznv//9rypUqCBvb281bdrUUOetXLlyRb1791bbtm317bffqnnz5ipdurTq1auniRMnatq0abd8X2xsrLp166ZixYrJx8dH1atX15dffmk4ZtGiRapevbq8vb0VFBSk5s2bKz4+XtLNFOW+++6Tr6+v8ubNq4YNG+rIkSO3rRUAkHnQMADIMby9vQ1JwurVq7Vv3z6tXLlS33//va5fv65WrVrJ399fv/zyi3777Tf5+fmpdevWye979913NWvWLM2YMUO//vqrzp07pyVLltz2uk8//bS+/PJLffDBB9qzZ4+mTZsmPz8/lShRQosXL5Yk7du3T9HR0Zo8ebIkKTw8XHPmzNEnn3yi3bt36+WXX1aPHj0UEREh6WZj06lTJ7Vr107bt2/Xs88+q1dfffW2daxYsUJnz57VsGHDbrk/b968txxPSEhQnTp19MMPP2jXrl16/vnn9dRTT+n333+XJEVHR6tbt2565plntGfPHq1du1adOnWS0+nUjRs31KFDBzVu3Fg7duzQhg0b9Pzzz8tms922VgBAJuIEgGyoZ8+ezvbt2zudTqczKSnJuXLlSqfdbncOGTIkeX/hwoWdDocj+T1z5851VqxY0ZmUlJQ85nA4nN7e3s4VK1Y4nU6ns0iRIs7x48cn779+/bqzePHiyddyOp3Oxo0bO1966SWn0+l07tu3zynJuXLlylvW+fPPPzslOc+fP588lpCQ4PTx8XGuX7/ecGyfPn2c3bp1czqdTmdYWJizSpUqhv2vvPJKinO5euedd5ySnOfOnbvl/tvV9E8PP/ywc/DgwU6n0+mMjIx0SnIePnw4xXGxsbFOSc61a9fe9poAgMwrl4W9CgCkq++//15+fn66fv26kpKS1L17d40cOTJ5f/Xq1ZUnT57k13/88YeioqJSrD9ISEjQgQMHFBcXp+joaNWrVy95X65cuVS3bt0U05L+tn37dnl6eqpx48aprjsqKkpXrlxRixYtDOPXrl3TPffcI0nas2ePoQ5JatCgwW3Pa1bjnSQmJmrs2LFauHChTpw4oWvXrsnhcMjHx0eSVLNmTTVr1kzVq1dXq1at1LJlSz322GPKly+f8ufPr169eqlVq1Zq0aKFmjdvri5duqhIkSJ3VQsAIOPRMADItpo2baqpU6cqT548Klq0qHLlMv4nz9fX1/D68uXLqlOnjubNm5fiXAULFryrGry9vd1+z+XLlyVJP/zwg4oVK2bYZ7fb76oOSapQoYIkae/evXdsLlxNmDBBkydP1qRJk1S9enX5+vpq4MCBydO0PD09tXLlSq1fv14//fSTPvzwQ73++uvatGmTSpcurZkzZ+rFF1/U8uXL9dVXX2n48OFauXKl6tevf9c/CwAg47CGAUC25evrq3LlyqlkyZIpmoVbqV27tvbv369ChQqpXLlyhi0wMFCBgYEqUqSINm3alPyeGzduKDIy0vSc1atXV1JSUvLag3/6O+FITExMHqtSpYrsdruOHj2aoo4SJUpIkipXrpy8huBvGzduvO3P17JlSxUoUEDjx4+/5X6zW7v+9ttvat++vXr06KGaNWuqTJkyKW7BarPZ1LBhQ40aNUrbtm1Tnjx5DGs77rnnHoWFhWn9+vWqVq2a5s+ff9taAQCZBw0DAPzPk08+qQIFCqh9+/b65ZdfdOjQIa1du1Yvvviijh8/Lkl66aWXNG7cOC1dulR79+7VCy+8cNtnKJQqVUo9e/bUM888o6VLlyafc+HChZKkkJAQ2Ww2ff/994qJidHly5fl7++vIUOG6OWXX9bs2bN14MABbd26VR9++KFmz54tSerXr5/279+voUOHat++fZo/f75mzZp125/P19dXn332mX744Qc9+uijWrVqlQ4fPqwtW7Zo2LBh6tev3y3fV758+eQEYc+ePerbt69Onz6dvH/Tpk0aO3astmzZoqNHj+qbb75RTEyMKleurEOHDiksLEwbNmzQkSNH9NNPP2n//v2qXLmyG98MAMBKNAwA8D8+Pj5at26dSpYsqU6dOqly5crq06ePEhISFBAQIEkaPHiwnnrqKfXs2VMNGjSQv7+/OnbseNvzTp06VY899pheeOEFVapUSc8991zyLUeLFSumUaNG6dVXX1XhwoXVv39/SdJbb72lN954Q+Hh4apcubJat26tH374QaVLl5YklSxZUosXL9bSpUtVs2ZNffLJJxo7duwdf8b27dtr/fr1yp07t7p3765KlSqpW7duiouL05gxY275nuHDh6t27dpq1aqVmjRpouDgYMOTrQMCArRu3Tq1bdtWFSpU0PDhw/Xuu++qTZs28vHx0d69e9W5c2dVqFBBzz//vEJDQ9W3b9871goAyBxszrtdBQcAAAAg2yNhAAAAAGCKhgEAAACAKRoGAAAAAKZoGAAAAACYomEAAAAAYIqGAQAAAIApGgYAAAAApmgYAAAAAJiiYQAAAABgioYBAAAAgCkaBgAAAACm/g/G75NJyqUhpAAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 1000x800 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import seaborn as sns\n",
        "\n",
        "num_classes = 5\n",
        "\n",
        "# Compute the confusion matrix\n",
        "conf_matrix = confusion_matrix(all_true_labels, [np.argmax(p) for p in all_probs])\n",
        "\n",
        "# Adjust the labels to start from 1 instead of 0\n",
        "labels = range(1, num_classes + 1)\n",
        "\n",
        "# Plot the confusion matrix\n",
        "plt.figure(figsize=(10, 8))\n",
        "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)\n",
        "plt.xlabel('Predicted Class')\n",
        "plt.ylabel('True Class')\n",
        "plt.title('Confusion Matrix')\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 346
        },
        "id": "Yjsw08Ddp4MD",
        "outputId": "456ff147-6314-48e0-c0c2-e15688569e3b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1800x600 with 3 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Ensure all elements are floats\n",
        "train_loss_list = [loss.item() if torch.is_tensor(loss) else loss for loss in train_loss_list]\n",
        "val_loss_list = [loss.item() if torch.is_tensor(loss) else loss for loss in val_loss_list]\n",
        "train_accuracy_list = [accuracy.cpu().numpy() if torch.is_tensor(accuracy) else accuracy for accuracy in train_accuracy_list]\n",
        "val_accuracy_list = [accuracy.cpu().numpy() if torch.is_tensor(accuracy) else accuracy for accuracy in val_accuracy_list]\n",
        "\n",
        "# Plot training and validation loss\n",
        "plt.figure(figsize=(18, 6))\n",
        "\n",
        "plt.subplot(1, 3, 1)\n",
        "plt.plot(range(len(train_loss_list)), train_loss_list, label='Training Loss')\n",
        "plt.plot(range(len(val_loss_list)), val_loss_list, label='Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.title('Training and Validation Loss')\n",
        "\n",
        "# Plot training and validation accuracy\n",
        "plt.subplot(1, 3, 2)\n",
        "plt.plot(range(len(train_accuracy_list)), train_accuracy_list, label='Training Accuracy')\n",
        "plt.plot(range(len(val_accuracy_list)), val_accuracy_list, label='Validation Accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.title('Training and Validation Accuracy')\n",
        "\n",
        "# Plot mean absolute error\n",
        "plt.subplot(1, 3, 3)\n",
        "plt.plot(range(len(mae_list)), mae_list, label='Mean Absolute Error')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('MAE')\n",
        "plt.legend()\n",
        "plt.title('Mean Absolute Error')\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_pO9AT82MY9T",
        "outputId": "1f0081db-2950-4108-b430-e1aca9363b09"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Filename: D_681.png, True PAI: 1, Predicted PAI: 2, Probability: 0.9948\n",
            "Filename: D_32.png, True PAI: 1, Predicted PAI: 1, Probability: 0.6508\n",
            "Filename: S_536.png, True PAI: 3, Predicted PAI: 1, Probability: 0.4215\n",
            "Filename: D_71.png, True PAI: 4, Predicted PAI: 4, Probability: 1.0000\n",
            "Filename: G_120.png, True PAI: 3, Predicted PAI: 3, Probability: 0.7451\n",
            "Filename: D_6.png, True PAI: 3, Predicted PAI: 3, Probability: 0.6689\n",
            "Filename: S_40.png, True PAI: 2, Predicted PAI: 2, Probability: 0.5435\n",
            "Filename: D_421.png, True PAI: 5, Predicted PAI: 5, Probability: 0.5314\n",
            "Filename: S_308.png, True PAI: 2, Predicted PAI: 2, Probability: 0.9859\n",
            "Filename: G_31.png, True PAI: 1, Predicted PAI: 2, Probability: 0.7787\n",
            "Filename: S_271.png, True PAI: 3, Predicted PAI: 2, Probability: 0.4160\n",
            "Filename: G_125.png, True PAI: 4, Predicted PAI: 2, Probability: 0.9351\n",
            "Filename: D_679.png, True PAI: 4, Predicted PAI: 5, Probability: 0.3105\n",
            "Filename: D_34.png, True PAI: 3, Predicted PAI: 3, Probability: 0.8413\n",
            "Filename: D_612.png, True PAI: 3, Predicted PAI: 1, Probability: 0.7237\n",
            "Filename: D_572.png, True PAI: 3, Predicted PAI: 1, Probability: 0.9468\n",
            "Filename: G_225.png, True PAI: 1, Predicted PAI: 2, Probability: 0.9954\n",
            "Filename: G_131.png, True PAI: 3, Predicted PAI: 3, Probability: 0.9963\n",
            "Filename: S_61.png, True PAI: 4, Predicted PAI: 1, Probability: 0.6204\n",
            "Filename: S_161.png, True PAI: 1, Predicted PAI: 1, Probability: 0.9289\n",
            "Filename: D_714.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9724\n",
            "Filename: G_66.png, True PAI: 2, Predicted PAI: 4, Probability: 0.7616\n",
            "Filename: D_400.png, True PAI: 3, Predicted PAI: 1, Probability: 0.7712\n",
            "Filename: G_206.png, True PAI: 2, Predicted PAI: 2, Probability: 0.9932\n",
            "Filename: D_360.png, True PAI: 3, Predicted PAI: 1, Probability: 0.5966\n",
            "Filename: S_391.png, True PAI: 2, Predicted PAI: 3, Probability: 0.3978\n",
            "Filename: D_255.png, True PAI: 3, Predicted PAI: 3, Probability: 0.9550\n",
            "Filename: G_193.png, True PAI: 3, Predicted PAI: 3, Probability: 0.9978\n",
            "Filename: S_389.png, True PAI: 3, Predicted PAI: 2, Probability: 0.3830\n",
            "Filename: D_239.png, True PAI: 3, Predicted PAI: 2, Probability: 0.6813\n",
            "Filename: D_546.png, True PAI: 3, Predicted PAI: 2, Probability: 0.7325\n",
            "Filename: G_50.png, True PAI: 3, Predicted PAI: 4, Probability: 0.9998\n",
            "Filename: D_681.png, True PAI: 3, Predicted PAI: 3, Probability: 0.4855\n",
            "Filename: D_32.png, True PAI: 1, Predicted PAI: 1, Probability: 0.8533\n",
            "Filename: S_536.png, True PAI: 3, Predicted PAI: 3, Probability: 0.7897\n",
            "Filename: D_71.png, True PAI: 3, Predicted PAI: 3, Probability: 0.8573\n",
            "Filename: G_120.png, True PAI: 3, Predicted PAI: 4, Probability: 0.8121\n",
            "Filename: D_6.png, True PAI: 1, Predicted PAI: 1, Probability: 0.9678\n",
            "Filename: S_40.png, True PAI: 3, Predicted PAI: 1, Probability: 0.8080\n",
            "Filename: D_421.png, True PAI: 3, Predicted PAI: 2, Probability: 0.5343\n",
            "Filename: S_308.png, True PAI: 3, Predicted PAI: 4, Probability: 0.4808\n",
            "Filename: G_31.png, True PAI: 3, Predicted PAI: 3, Probability: 0.6622\n",
            "Filename: S_271.png, True PAI: 3, Predicted PAI: 3, Probability: 0.7199\n",
            "Filename: G_125.png, True PAI: 2, Predicted PAI: 2, Probability: 0.5554\n",
            "Filename: D_679.png, True PAI: 1, Predicted PAI: 3, Probability: 0.5861\n",
            "Filename: D_34.png, True PAI: 3, Predicted PAI: 2, Probability: 0.9864\n",
            "Filename: D_612.png, True PAI: 2, Predicted PAI: 2, Probability: 0.8205\n",
            "Filename: D_572.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9999\n",
            "Filename: G_225.png, True PAI: 4, Predicted PAI: 3, Probability: 0.9381\n",
            "Filename: G_131.png, True PAI: 3, Predicted PAI: 3, Probability: 0.4861\n",
            "Filename: S_61.png, True PAI: 3, Predicted PAI: 1, Probability: 0.9184\n",
            "Filename: S_161.png, True PAI: 2, Predicted PAI: 3, Probability: 0.7798\n",
            "Filename: D_714.png, True PAI: 1, Predicted PAI: 1, Probability: 0.6528\n",
            "Filename: G_66.png, True PAI: 2, Predicted PAI: 1, Probability: 0.6326\n",
            "Filename: D_400.png, True PAI: 5, Predicted PAI: 4, Probability: 0.3635\n",
            "Filename: G_206.png, True PAI: 3, Predicted PAI: 3, Probability: 0.6536\n",
            "Filename: D_360.png, True PAI: 2, Predicted PAI: 3, Probability: 0.8633\n",
            "Filename: S_391.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9966\n",
            "Filename: D_255.png, True PAI: 3, Predicted PAI: 3, Probability: 0.7709\n",
            "Filename: G_193.png, True PAI: 3, Predicted PAI: 3, Probability: 0.4486\n",
            "Filename: S_389.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9926\n",
            "Filename: D_239.png, True PAI: 3, Predicted PAI: 2, Probability: 0.6704\n",
            "Filename: D_546.png, True PAI: 3, Predicted PAI: 3, Probability: 0.6089\n",
            "Filename: G_50.png, True PAI: 4, Predicted PAI: 4, Probability: 0.4380\n",
            "Filename: D_681.png, True PAI: 3, Predicted PAI: 3, Probability: 0.3380\n",
            "Filename: D_32.png, True PAI: 3, Predicted PAI: 3, Probability: 0.4538\n",
            "Filename: S_536.png, True PAI: 2, Predicted PAI: 2, Probability: 1.0000\n",
            "Filename: D_71.png, True PAI: 3, Predicted PAI: 1, Probability: 0.4766\n",
            "Filename: G_120.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9990\n",
            "Filename: D_6.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9543\n",
            "Filename: S_40.png, True PAI: 1, Predicted PAI: 1, Probability: 0.5073\n",
            "Filename: D_421.png, True PAI: 3, Predicted PAI: 2, Probability: 0.3555\n",
            "Filename: S_308.png, True PAI: 1, Predicted PAI: 2, Probability: 0.6702\n",
            "Filename: G_31.png, True PAI: 3, Predicted PAI: 1, Probability: 0.7480\n",
            "Filename: S_271.png, True PAI: 3, Predicted PAI: 3, Probability: 0.8110\n",
            "Filename: G_125.png, True PAI: 3, Predicted PAI: 4, Probability: 0.7583\n",
            "Filename: D_679.png, True PAI: 3, Predicted PAI: 4, Probability: 0.4970\n",
            "Filename: D_34.png, True PAI: 3, Predicted PAI: 3, Probability: 0.6615\n",
            "Filename: D_612.png, True PAI: 1, Predicted PAI: 2, Probability: 0.9864\n",
            "Filename: D_572.png, True PAI: 5, Predicted PAI: 3, Probability: 0.7416\n",
            "Filename: G_225.png, True PAI: 3, Predicted PAI: 2, Probability: 0.4032\n",
            "Filename: G_131.png, True PAI: 1, Predicted PAI: 1, Probability: 0.4045\n",
            "Filename: S_61.png, True PAI: 3, Predicted PAI: 1, Probability: 0.8480\n",
            "Filename: S_161.png, True PAI: 5, Predicted PAI: 4, Probability: 0.5329\n",
            "Filename: D_714.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9233\n",
            "Filename: G_66.png, True PAI: 4, Predicted PAI: 1, Probability: 0.9644\n",
            "Filename: D_400.png, True PAI: 3, Predicted PAI: 3, Probability: 0.7140\n",
            "Filename: G_206.png, True PAI: 2, Predicted PAI: 3, Probability: 0.9569\n",
            "Filename: D_360.png, True PAI: 3, Predicted PAI: 1, Probability: 0.7133\n",
            "Filename: S_391.png, True PAI: 3, Predicted PAI: 4, Probability: 0.4491\n",
            "Filename: D_255.png, True PAI: 3, Predicted PAI: 3, Probability: 0.7111\n",
            "Filename: G_193.png, True PAI: 2, Predicted PAI: 3, Probability: 0.7578\n",
            "Filename: S_389.png, True PAI: 1, Predicted PAI: 1, Probability: 0.7644\n",
            "Filename: D_239.png, True PAI: 2, Predicted PAI: 2, Probability: 0.7439\n",
            "Filename: D_546.png, True PAI: 4, Predicted PAI: 3, Probability: 0.6119\n",
            "Filename: G_50.png, True PAI: 2, Predicted PAI: 3, Probability: 0.4451\n",
            "Filename: D_681.png, True PAI: 5, Predicted PAI: 4, Probability: 0.5902\n",
            "Filename: D_32.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9804\n",
            "Filename: S_536.png, True PAI: 1, Predicted PAI: 1, Probability: 0.9053\n",
            "Filename: D_71.png, True PAI: 3, Predicted PAI: 1, Probability: 0.8965\n",
            "Filename: G_120.png, True PAI: 3, Predicted PAI: 3, Probability: 0.8103\n",
            "Filename: D_6.png, True PAI: 1, Predicted PAI: 2, Probability: 0.7470\n",
            "Filename: S_40.png, True PAI: 4, Predicted PAI: 3, Probability: 0.4445\n",
            "Filename: D_421.png, True PAI: 3, Predicted PAI: 1, Probability: 0.8343\n",
            "Filename: S_308.png, True PAI: 4, Predicted PAI: 1, Probability: 0.5179\n",
            "Filename: G_31.png, True PAI: 4, Predicted PAI: 4, Probability: 0.5963\n",
            "Filename: S_271.png, True PAI: 1, Predicted PAI: 1, Probability: 0.5574\n",
            "Filename: G_125.png, True PAI: 4, Predicted PAI: 3, Probability: 0.5157\n",
            "Filename: D_679.png, True PAI: 3, Predicted PAI: 5, Probability: 0.5898\n",
            "Filename: D_34.png, True PAI: 1, Predicted PAI: 3, Probability: 0.8904\n",
            "Filename: D_612.png, True PAI: 1, Predicted PAI: 1, Probability: 0.8375\n",
            "Filename: D_572.png, True PAI: 1, Predicted PAI: 2, Probability: 0.8108\n",
            "Filename: G_225.png, True PAI: 3, Predicted PAI: 2, Probability: 0.9980\n",
            "Filename: G_131.png, True PAI: 3, Predicted PAI: 1, Probability: 0.4805\n",
            "Filename: S_61.png, True PAI: 1, Predicted PAI: 1, Probability: 0.6088\n",
            "Filename: S_161.png, True PAI: 1, Predicted PAI: 1, Probability: 0.9991\n",
            "Filename: D_714.png, True PAI: 3, Predicted PAI: 3, Probability: 0.4654\n",
            "Filename: G_66.png, True PAI: 1, Predicted PAI: 1, Probability: 0.8887\n",
            "Filename: D_400.png, True PAI: 3, Predicted PAI: 1, Probability: 0.6961\n",
            "Filename: G_206.png, True PAI: 1, Predicted PAI: 1, Probability: 0.6623\n",
            "Filename: D_360.png, True PAI: 1, Predicted PAI: 2, Probability: 0.5453\n",
            "Filename: S_391.png, True PAI: 3, Predicted PAI: 1, Probability: 0.5107\n",
            "Filename: D_255.png, True PAI: 2, Predicted PAI: 2, Probability: 1.0000\n",
            "Filename: G_193.png, True PAI: 3, Predicted PAI: 1, Probability: 0.5481\n",
            "Filename: S_389.png, True PAI: 3, Predicted PAI: 2, Probability: 0.9523\n",
            "Filename: D_239.png, True PAI: 4, Predicted PAI: 1, Probability: 0.5862\n",
            "Filename: D_546.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9981\n",
            "Filename: G_50.png, True PAI: 2, Predicted PAI: 2, Probability: 0.9958\n",
            "Filename: D_681.png, True PAI: 1, Predicted PAI: 1, Probability: 0.8731\n",
            "Filename: D_32.png, True PAI: 4, Predicted PAI: 1, Probability: 0.5154\n",
            "Filename: S_536.png, True PAI: 5, Predicted PAI: 5, Probability: 1.0000\n",
            "Filename: D_71.png, True PAI: 4, Predicted PAI: 4, Probability: 1.0000\n",
            "Filename: G_120.png, True PAI: 4, Predicted PAI: 4, Probability: 0.5992\n",
            "Filename: D_6.png, True PAI: 2, Predicted PAI: 3, Probability: 0.5526\n",
            "Filename: S_40.png, True PAI: 1, Predicted PAI: 2, Probability: 0.8420\n",
            "Filename: D_421.png, True PAI: 1, Predicted PAI: 1, Probability: 0.7184\n",
            "Filename: S_308.png, True PAI: 3, Predicted PAI: 1, Probability: 0.8599\n",
            "Filename: G_31.png, True PAI: 3, Predicted PAI: 3, Probability: 0.8453\n",
            "Filename: S_271.png, True PAI: 2, Predicted PAI: 3, Probability: 0.4489\n",
            "Filename: G_125.png, True PAI: 2, Predicted PAI: 2, Probability: 0.9945\n",
            "Filename: D_679.png, True PAI: 3, Predicted PAI: 4, Probability: 0.8351\n",
            "Filename: D_34.png, True PAI: 1, Predicted PAI: 4, Probability: 0.4666\n",
            "Filename: D_612.png, True PAI: 3, Predicted PAI: 1, Probability: 0.9905\n",
            "Filename: D_572.png, True PAI: 3, Predicted PAI: 1, Probability: 0.7196\n",
            "Filename: G_225.png, True PAI: 5, Predicted PAI: 3, Probability: 0.7431\n",
            "Filename: G_131.png, True PAI: 2, Predicted PAI: 2, Probability: 0.8991\n",
            "Filename: S_61.png, True PAI: 3, Predicted PAI: 2, Probability: 0.9989\n",
            "Filename: S_161.png, True PAI: 1, Predicted PAI: 1, Probability: 0.7126\n",
            "Filename: D_714.png, True PAI: 1, Predicted PAI: 1, Probability: 0.7568\n",
            "Filename: G_66.png, True PAI: 1, Predicted PAI: 1, Probability: 0.7231\n",
            "Filename: D_400.png, True PAI: 1, Predicted PAI: 1, Probability: 0.7774\n",
            "Filename: G_206.png, True PAI: 5, Predicted PAI: 4, Probability: 1.0000\n",
            "Filename: D_360.png, True PAI: 3, Predicted PAI: 1, Probability: 0.3704\n",
            "Filename: S_391.png, True PAI: 1, Predicted PAI: 1, Probability: 0.4573\n",
            "Filename: D_255.png, True PAI: 3, Predicted PAI: 2, Probability: 0.9946\n",
            "Filename: G_193.png, True PAI: 3, Predicted PAI: 5, Probability: 0.9107\n",
            "Filename: S_389.png, True PAI: 3, Predicted PAI: 3, Probability: 0.7274\n",
            "Filename: D_239.png, True PAI: 3, Predicted PAI: 3, Probability: 0.9613\n",
            "Filename: D_546.png, True PAI: 5, Predicted PAI: 3, Probability: 0.7749\n",
            "Filename: G_50.png, True PAI: 2, Predicted PAI: 1, Probability: 0.8924\n",
            "Filename: D_681.png, True PAI: 1, Predicted PAI: 1, Probability: 0.8846\n",
            "Filename: D_32.png, True PAI: 3, Predicted PAI: 3, Probability: 0.6058\n",
            "Filename: S_536.png, True PAI: 1, Predicted PAI: 1, Probability: 0.9967\n",
            "Filename: D_71.png, True PAI: 1, Predicted PAI: 2, Probability: 0.5677\n",
            "Filename: G_120.png, True PAI: 2, Predicted PAI: 3, Probability: 0.6378\n",
            "Filename: D_6.png, True PAI: 3, Predicted PAI: 1, Probability: 0.7123\n",
            "Filename: S_40.png, True PAI: 3, Predicted PAI: 1, Probability: 0.6693\n",
            "Filename: D_421.png, True PAI: 1, Predicted PAI: 1, Probability: 0.8199\n",
            "Filename: S_308.png, True PAI: 4, Predicted PAI: 1, Probability: 0.5278\n",
            "Filename: G_31.png, True PAI: 1, Predicted PAI: 1, Probability: 0.5339\n",
            "Filename: S_271.png, True PAI: 2, Predicted PAI: 2, Probability: 0.5036\n",
            "Filename: G_125.png, True PAI: 4, Predicted PAI: 4, Probability: 0.5382\n",
            "Filename: D_679.png, True PAI: 3, Predicted PAI: 4, Probability: 0.6406\n",
            "Filename: D_34.png, True PAI: 2, Predicted PAI: 2, Probability: 0.5533\n",
            "Filename: D_612.png, True PAI: 5, Predicted PAI: 4, Probability: 1.0000\n",
            "Filename: D_572.png, True PAI: 3, Predicted PAI: 3, Probability: 0.8435\n",
            "Filename: G_225.png, True PAI: 4, Predicted PAI: 2, Probability: 0.9550\n",
            "Filename: G_131.png, True PAI: 2, Predicted PAI: 1, Probability: 0.8433\n",
            "Filename: S_61.png, True PAI: 2, Predicted PAI: 5, Probability: 0.9624\n",
            "Filename: S_161.png, True PAI: 3, Predicted PAI: 3, Probability: 0.7500\n",
            "Filename: D_714.png, True PAI: 4, Predicted PAI: 2, Probability: 0.7188\n",
            "Filename: G_66.png, True PAI: 2, Predicted PAI: 3, Probability: 0.9998\n",
            "Filename: D_400.png, True PAI: 3, Predicted PAI: 4, Probability: 0.8399\n",
            "Filename: G_206.png, True PAI: 3, Predicted PAI: 3, Probability: 0.9995\n",
            "Filename: D_360.png, True PAI: 2, Predicted PAI: 3, Probability: 0.5366\n",
            "Filename: S_391.png, True PAI: 3, Predicted PAI: 3, Probability: 0.6089\n",
            "Filename: D_255.png, True PAI: 2, Predicted PAI: 1, Probability: 0.8801\n",
            "Filename: G_193.png, True PAI: 1, Predicted PAI: 4, Probability: 0.7314\n",
            "Filename: S_389.png, True PAI: 3, Predicted PAI: 3, Probability: 0.9208\n",
            "Filename: D_239.png, True PAI: 2, Predicted PAI: 3, Probability: 0.5071\n",
            "Filename: D_546.png, True PAI: 1, Predicted PAI: 1, Probability: 0.4990\n",
            "Filename: G_50.png, True PAI: 4, Predicted PAI: 2, Probability: 0.7099\n",
            "Filename: D_681.png, True PAI: 3, Predicted PAI: 1, Probability: 0.7722\n",
            "Filename: D_32.png, True PAI: 3, Predicted PAI: 3, Probability: 0.5382\n",
            "Filename: S_536.png, True PAI: 3, Predicted PAI: 4, Probability: 0.8751\n",
            "Filename: D_71.png, True PAI: 3, Predicted PAI: 3, Probability: 0.4066\n",
            "Filename: G_120.png, True PAI: 2, Predicted PAI: 1, Probability: 0.4996\n",
            "Filename: D_6.png, True PAI: 3, Predicted PAI: 4, Probability: 0.9979\n",
            "Filename: S_40.png, True PAI: 2, Predicted PAI: 2, Probability: 0.5970\n",
            "Filename: D_421.png, True PAI: 4, Predicted PAI: 4, Probability: 0.8180\n",
            "Filename: S_308.png, True PAI: 1, Predicted PAI: 3, Probability: 0.8965\n",
            "Filename: G_31.png, True PAI: 3, Predicted PAI: 1, Probability: 0.5491\n",
            "Filename: S_271.png, True PAI: 5, Predicted PAI: 4, Probability: 0.5004\n",
            "Filename: G_125.png, True PAI: 3, Predicted PAI: 1, Probability: 0.6669\n",
            "Filename: D_679.png, True PAI: 3, Predicted PAI: 3, Probability: 0.9652\n",
            "Filename: D_34.png, True PAI: 2, Predicted PAI: 3, Probability: 0.9114\n",
            "Filename: D_612.png, True PAI: 2, Predicted PAI: 1, Probability: 0.9171\n",
            "Filename: D_572.png, True PAI: 4, Predicted PAI: 4, Probability: 1.0000\n",
            "Filename: G_225.png, True PAI: 4, Predicted PAI: 2, Probability: 0.7161\n",
            "Filename: G_131.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9041\n",
            "Filename: S_61.png, True PAI: 4, Predicted PAI: 4, Probability: 0.9788\n",
            "Filename: S_161.png, True PAI: 3, Predicted PAI: 2, Probability: 0.5734\n",
            "Filename: D_714.png, True PAI: 3, Predicted PAI: 3, Probability: 0.5052\n",
            "Filename: G_66.png, True PAI: 2, Predicted PAI: 3, Probability: 0.5211\n",
            "Filename: D_400.png, True PAI: 2, Predicted PAI: 2, Probability: 0.6859\n",
            "Filename: G_206.png, True PAI: 2, Predicted PAI: 3, Probability: 0.8037\n",
            "Filename: D_360.png, True PAI: 3, Predicted PAI: 4, Probability: 0.5529\n",
            "Filename: S_391.png, True PAI: 4, Predicted PAI: 4, Probability: 0.8295\n",
            "Filename: D_255.png, True PAI: 1, Predicted PAI: 2, Probability: 0.8758\n",
            "Filename: G_193.png, True PAI: 3, Predicted PAI: 3, Probability: 0.4573\n",
            "Filename: S_389.png, True PAI: 1, Predicted PAI: 1, Probability: 0.3612\n",
            "Filename: D_239.png, True PAI: 1, Predicted PAI: 2, Probability: 0.7300\n",
            "Filename: D_546.png, True PAI: 4, Predicted PAI: 5, Probability: 0.2592\n",
            "Filename: G_50.png, True PAI: 1, Predicted PAI: 2, Probability: 0.5196\n",
            "Filename: D_681.png, True PAI: 3, Predicted PAI: 2, Probability: 0.3956\n"
          ]
        }
      ],
      "source": [
        "def run_inference(model, dataloader, device):\n",
        "    model.eval()\n",
        "    results = []\n",
        "    with torch.no_grad():\n",
        "        for inputs, labels, weights in dataloader:\n",
        "            inputs = inputs.to(device)\n",
        "            labels = labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "            probs = torch.softmax(outputs, dim=1)\n",
        "            _, preds = torch.max(outputs, 1)\n",
        "\n",
        "            # Collect data\n",
        "            for i in range(inputs.size(0)):\n",
        "                filename = dataloader.dataset.data.iloc[i]['filename']\n",
        "                true_pai = labels[i].item() + 1  # Converting back to 1-based index\n",
        "                predicted_pai = preds[i].item() + 1  # Converting back to 1-based index\n",
        "                probability = probs[i][preds[i]].item()\n",
        "\n",
        "                results.append({\n",
        "                    'filename': filename,\n",
        "                    'true_pai': true_pai,\n",
        "                    'predicted_pai': predicted_pai,\n",
        "                    'probability': probability\n",
        "                })\n",
        "    return results\n",
        "\n",
        "# Run inference on the validation dataset\n",
        "results = run_inference(model, val_loader, device)\n",
        "\n",
        "# Print the results\n",
        "for result in results:\n",
        "    print(f\"Filename: {result['filename']}, True PAI: {result['true_pai']}, Predicted PAI: {result['predicted_pai']}, Probability: {result['probability']:.4f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-TCwtTfTTBHj"
      },
      "outputs": [],
      "source": [
        "# Convert results to DataFrame\n",
        "results_df = pd.DataFrame(results)\n",
        "\n",
        "# Save to CSV\n",
        "results_df.to_csv('results.csv', index=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-iNE7PcCFcsr",
        "outputId": "2c6b1b45-745a-4c81-81a9-7f763586a650"
      },
      "outputs": [],
      "source": [
        "# Assuming 'model' is your fine-tuned model\n",
        "model_path = 'path to save model'\n",
        "torch.save(model.state_dict(), model_path)\n",
        "print(f\"Model saved to {model_path}\")"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "L4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}