diff --git a/Colab version.ipynb b/Colab version.ipynb new file mode 100644 index 000000000..ddb2b7e3e --- /dev/null +++ b/Colab version.ipynb @@ -0,0 +1,986 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yzCmT9TUJY10", + "outputId": "8e10d31b-6fc4-4a4a-fdc8-078f4a36b02b" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount(\"/content/drive\", force_remount=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-Lb7CGdEJCQg", + "outputId": "a57f82f8-7816-4bd4-a54e-1e48cab3c3f8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/root\n" + ] + } + ], + "source": [ + "%cd" + ] + }, + { + "cell_type": "code", + "source": [ + "torch.save(trip_model.state_dict(), '/content/drive/MyDrive/model.pth')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 373 + }, + "id": "ZpU3tv9IGwCB", + "outputId": "11b0d223-3170-4756-825b-922cc5bcbe07" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "error", + "ename": "RuntimeError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrip_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate_dict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'/content/drive/MyDrive/model.pth'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/serialization.py\u001b[0m in \u001b[0;36msave\u001b[0;34m(obj, f, pickle_module, pickle_protocol, _use_new_zipfile_serialization)\u001b[0m\n\u001b[1;32m 439\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m_use_new_zipfile_serialization\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 440\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0m_open_zipfile_writer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mopened_zipfile\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 441\u001b[0;31m \u001b[0m_save\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mopened_zipfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpickle_module\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpickle_protocol\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 442\u001b[0m \u001b[0;32mreturn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 443\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/serialization.py\u001b[0m in \u001b[0;36m_save\u001b[0;34m(obj, zip_file, pickle_module, pickle_protocol)\u001b[0m\n\u001b[1;32m 663\u001b[0m \u001b[0;31m# .cpu() on the underlying Storage\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 664\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstorage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;34m'cpu'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 665\u001b[0;31m \u001b[0mstorage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstorage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 666\u001b[0m \u001b[0;31m# Now that it is on the CPU we can directly copy it into the zip file\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 667\u001b[0m \u001b[0mnum_bytes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstorage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnbytes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/storage.py\u001b[0m in \u001b[0;36mcpu\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;34m\"\"\"Returns a CPU copy of this storage if it's not already on the CPU\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 120\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;34m'cpu'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 121\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mUntypedStorage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 122\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRuntimeError\u001b[0m: CUDA error: device-side assert triggered\nCUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1.\nCompile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PM8uTdbZpQGJ", + "outputId": "7b33eba8-1ff0-4df6-d785-81f57a27ba69" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['AD_NC']\n" + ] + } + ], + "source": [ + "import zipfile\n", + "import os\n", + "\n", + "# Define the paths\n", + "zip_path = '/content/drive/MyDrive/AD_NC.zip' # Path to the zip file\n", + "extract_path = '/content/extracted_folder' # Path where you want to extract the contents\n", + "\n", + "# Unzip the file\n", + "with zipfile.ZipFile(zip_path, 'r') as zip_ref:\n", + " zip_ref.extractall(extract_path)\n", + "\n", + "# List the contents of the extracted folder\n", + "extracted_files = os.listdir(extract_path)\n", + "print(extracted_files)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "x1t1iFV_p2MU", + "outputId": "21e66a1e-e2c5-422d-ab47-dd1d15d03b89" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content/extracted_folder/AD_NC\n" + ] + } + ], + "source": [ + "cd /content/extracted_folder/AD_NC" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Tp_Fb7Eyp-yv", + "outputId": "2c834d95-b421-4b45-a308-267acefd6334" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[0m\u001b[01;34mtest\u001b[0m/ \u001b[01;34mtrain\u001b[0m/\n" + ] + } + ], + "source": [ + "ls" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "_8PBaJLSJSCP" + }, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import torch.nn.functional as F\n", + "import torchvision.transforms as transforms\n", + "import time\n", + "import numpy as np\n", + "# import pandas as pd\n", + "import math\n", + "import os\n", + "from PIL import Image\n", + "import numpy as np\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from sklearn.utils import shuffle\n", + "import torch\n", + "from torch.utils.data import DataLoader\n", + "from torchvision.datasets import ImageFolder\n", + "\n", + "\n", + "import numpy as np\n", + "from torch.utils.data import Dataset, DataLoader, TensorDataset, ConcatDataset\n", + "import random\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "dlrwhZTjTKWf" + }, + "outputs": [], + "source": [ + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "batch_size = 96\n", + "from torch.utils.data.dataset import Subset, random_split\n", + "\n", + "class CustomDataset(Dataset):\n", + " def __init__(self, root_dir, transform=None):\n", + " self.root_dir = root_dir\n", + " self.transform = transform\n", + " self.image_paths = os.listdir(root_dir)\n", + "\n", + " def __len__(self):\n", + " return len(self.image_paths)\n", + "\n", + " def __getitem__(self, idx):\n", + " img_name = os.path.join(self.root_dir, self.image_paths[idx])\n", + " image = Image.open(img_name)\n", + "\n", + " if self.transform:\n", + " image = self.transform(image)\n", + "\n", + " return image\n", + "\n", + "class TripletDataset(Dataset):\n", + " def __init__(self, AD, NC, transform=None):\n", + " self.X = AD + NC\n", + " self.AD = AD\n", + " self.NC = NC\n", + " self.Y = torch.cat((torch.ones(len(AD)), torch.zeros(len(NC))), dim=0)\n", + " self.anc_indices = torch.randperm(len(self.X))\n", + " self.pos_indices = torch.randperm(len(self.X)) % len(AD)\n", + " self.neg_indices = torch.randperm(len(self.X)) % len(NC)\n", + " self.transform = transform\n", + "\n", + " def __len__(self):\n", + " return len(self.anc_indices)\n", + "\n", + " def __getitem__(self, idx):\n", + " anc = self.anc_indices[idx]\n", + " pos = self.pos_indices[idx]\n", + " neg = self.neg_indices[idx]\n", + " img1 = self.X[anc]\n", + " img2 = self.AD[pos]\n", + " img3 = self.NC[neg]\n", + " label = self.Y[anc]\n", + "\n", + " if self.transform:\n", + " img1 = self.transform(img1)\n", + " img2 = self.transform(img2)\n", + " img3 = self.transform(img3)\n", + "\n", + " return img1, img2, img3, torch.tensor([1 - label, label])\n", + "\n", + "\n", + "size = 128\n", + "\n", + "def intensity_normalization(img, mean = None, std = None):\n", + " mean = torch.mean(img)\n", + " std = torch.std(img)\n", + " return (img - mean) / std\n", + "\n", + "class CustomNormalize(object):\n", + " def __init__(self, mean, std):\n", + " self.mean = mean\n", + " self.std = std\n", + "\n", + " def __call__(self, img):\n", + " return (img - self.mean) / self.std\n", + "\n", + "transform_train = transforms.Compose([\n", + " transforms.Resize((size, size)),\n", + " transforms.ToTensor(),\n", + " transforms.RandomAffine(degrees=5, translate=(0.05, 0.05), scale=(0.95, 1.05)), # Random affine transformations with smaller parameters\n", + " transforms.Lambda(intensity_normalization)\n", + "])\n", + "\n", + "transform_test = transforms.Compose([\n", + " transforms.Resize((size, size)),\n", + " transforms.ToTensor(),\n", + " transforms.Lambda(intensity_normalization)\n", + "])\n", + "\n", + "class Normalize(object):\n", + " def __init__(self, mean, std):\n", + " self.mean = mean\n", + " self.std = std\n", + "\n", + " def __call__(self, img):\n", + " return (img - self.mean) / self.std\n", + "\n", + "\n", + "\n", + "# Replace 'your_nii_folder' with the path to your folder containing .nii files\n", + "# nii_dataset = NiiDataset(root_dir=r'keras_png_slices_data\\keras_png_slices_data\\keras_png_slices_train')\n", + "loaders = {}\n", + "AD_train = CustomDataset(root_dir=os.path.join('train', 'AD'), transform=transform_train)\n", + "NC_train = CustomDataset(root_dir=os.path.join('train', 'NC'), transform=transform_train)\n", + "\n", + "X = torch.stack([img for img in AD_train + NC_train])\n", + "mean = X.mean()\n", + "std = X.std()\n", + "normalize = transforms.Compose([\n", + " Normalize(mean, std)\n", + " ])\n", + "train_dataset = TripletDataset(AD_train, NC_train, normalize)\n", + "\n", + "\n", + "# Create data loaders for training and validation data\n", + "loaders['train'] = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n", + "\n", + "AD_test = CustomDataset(root_dir=os.path.join('test', 'AD'), transform=transform_test)\n", + "NC_test = CustomDataset(root_dir=os.path.join('test', 'NC'), transform=transform_test)\n", + "\n", + "test_dataset = TripletDataset(AD_test, NC_test, normalize)\n", + "\n", + "split_1 = int(0.5 * len(test_dataset))\n", + "split_2 = len(test_dataset) - split_1\n", + "\n", + "# Perform the split\n", + "test_dataset, cal_dataset = random_split(test_dataset, [split_1, split_2])\n", + "\n", + "loaders['cal'] = DataLoader(cal_dataset, batch_size=batch_size, shuffle=True)\n", + "loaders['test'] = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)" + ] + }, + { + "cell_type": "code", + "source": [ + "len(train_dataset), len(cal_dataset), len(test_dataset)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5RLuD3STujVC", + "outputId": "ea9b978b-4b8d-4466-81a6-61b943ab8b60" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(21520, 4500, 4500)" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "c8MhXUlOTHnY" + }, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torchvision.models as models\n", + "import torch.nn.functional as F\n", + "\n", + "class TripletSiameseNetwork(nn.Module):\n", + " def __init__(self, pretrained=True):\n", + " super(TripletSiameseNetwork, self).__init__()\n", + " self.resnet = models.resnet18(pretrained=pretrained)\n", + " self.resnet.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)\n", + " self.fc1 = nn.Linear(1000, 32)\n", + " # self.fc2 = nn.Linear(500, 32)\n", + "\n", + " def forward_once(self, x):\n", + " output = self.resnet(x)\n", + " output = self.fc1(output)\n", + " # output = self.fc2(output)\n", + " return output\n", + "\n", + " def forward(self, anchor, positive, negative):\n", + " output_anchor = self.forward_once(anchor)\n", + " output_positive = self.forward_once(positive)\n", + " output_negative = self.forward_once(negative)\n", + " return output_anchor, output_positive, output_negative\n", + "\n", + "class TripletLoss(nn.Module):\n", + " def __init__(self, margin=1.0):\n", + " super(TripletLoss, self).__init__()\n", + " self.margin = margin\n", + "\n", + " def forward(self, anchor, positive, negative):\n", + " distance_positive = F.pairwise_distance(anchor, positive)\n", + " distance_negative = F.pairwise_distance(anchor, negative)\n", + " losses = F.relu(distance_positive - distance_negative + self.margin)\n", + " return losses.mean()\n", + "\n", + "class TripletLossWithRegularization(nn.Module):\n", + " def __init__(self, margin=1.0, lambda_reg=0.0001):\n", + " super(TripletLossWithRegularization, self).__init__()\n", + " self.margin = margin\n", + " self.lambda_reg = lambda_reg # Regularization parameter\n", + "\n", + " def forward(self, anchor, positive, negative):\n", + " distance_positive = F.pairwise_distance(anchor, positive)\n", + " distance_negative = F.pairwise_distance(anchor, negative)\n", + " triplet_losses = F.relu(distance_positive - distance_negative + self.margin)\n", + " triplet_loss = triplet_losses.mean()\n", + "\n", + " # Compute L2 regularization\n", + " l2_reg = None\n", + " for param in trip_model.parameters():\n", + " if l2_reg is None:\n", + " l2_reg = param.norm(2)\n", + " else:\n", + " l2_reg = l2_reg + param.norm(2)\n", + "\n", + " loss = triplet_loss + self.lambda_reg * l2_reg\n", + " return loss\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "source": [ + "cd" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CkYaII4fGtTP", + "outputId": "68ab616f-0cdd-4f74-e160-33c1d4b65f69" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/root\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "Gs0V-oZe1O46", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 419 + }, + "outputId": "b2f0159b-02ad-4335-d7be-25001f9bb682" + }, + "outputs": [ + { + "output_type": "error", + "ename": "RuntimeError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlr_scheduler\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mStepLR\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mdevice\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'cuda'\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_available\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m'cpu'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mempty_cache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0mlearning_rate\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.05\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mtrip_model\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTripletSiameseNetwork\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/cuda/memory.py\u001b[0m in \u001b[0;36mempty_cache\u001b[0;34m()\u001b[0m\n\u001b[1;32m 131\u001b[0m \"\"\"\n\u001b[1;32m 132\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 133\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_C\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cuda_emptyCache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 134\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRuntimeError\u001b[0m: CUDA error: device-side assert triggered\nCUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1.\nCompile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.\n" + ] + } + ], + "source": [ + "from torch.optim.lr_scheduler import StepLR\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "torch.cuda.empty_cache()\n", + "learning_rate = 0.05\n", + "trip_model = TripletSiameseNetwork()\n", + "trip_criterion = TripletLossWithRegularization(margin=1.0)\n", + "val_criterion = TripletLoss(margin=1.0)\n", + "total_step = len(loaders['train'])\n", + "\n", + "# optimizer = optim.Adam(trip_model.parameters(), lr=learning_rate)\n", + "# scheduler = StepLR(optimizer, step_size=5, gamma=0.8)\n", + "optimizer = torch.optim.SGD(trip_model.parameters(), lr=learning_rate, momentum=0.9, weight_decay=5e-4)\n", + "\n", + "sched_linear_1 = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=0.005, max_lr=learning_rate, step_size_up=15, step_size_down=15, mode=\"triangular\", verbose=False)\n", + "sched_linear_3 = torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=0.005/learning_rate, end_factor=0.005/learning_rate, verbose=False)\n", + "scheduler = torch.optim.lr_scheduler.SequentialLR(optimizer, schedulers=[sched_linear_1, sched_linear_3], milestones=[30])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "A_J3lXLOUDu0", + "outputId": "9f42b2ed-30cd-41c6-a590-1a81844aa3d5" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch [1 / 10], Step [22 / 225], Loss: 1.5358287719163028, Validation Loss: 1.3388497829437256\n", + "Epoch [1 / 10], Step [44 / 225], Loss: 1.4194633120840245, Validation Loss: 1.2655972838401794\n", + "Epoch [1 / 10], Step [66 / 225], Loss: 1.2770680965799275, Validation Loss: 1.2275654872258503\n", + "Epoch [1 / 10], Step [88 / 225], Loss: 1.1987250704656949, Validation Loss: 1.1871682107448578\n", + "Epoch [1 / 10], Step [110 / 225], Loss: 1.1397959481586108, Validation Loss: 1.1396066188812255\n", + "Epoch [1 / 10], Step [132 / 225], Loss: 1.10812256146561, Validation Loss: 1.1233381430308025\n", + "Epoch [1 / 10], Step [154 / 225], Loss: 1.0751701558565165, Validation Loss: 1.0892583557537623\n", + "Epoch [1 / 10], Step [176 / 225], Loss: 1.0456692581488327, Validation Loss: 1.0730071142315865\n", + "Epoch [1 / 10], Step [198 / 225], Loss: 1.0179587769688982, Validation Loss: 1.034343745973375\n", + "Epoch [1 / 10], Step [220 / 225], Loss: 0.9846788463267413, Validation Loss: 0.9897604703903198\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch [2 / 10], Step [22 / 225], Loss: 0.5650029859759591, Validation Loss: 0.6480007767677307\n", + "Epoch [2 / 10], Step [44 / 225], Loss: 0.5132254456931894, Validation Loss: 0.5776327848434448\n", + "Epoch [2 / 10], Step [66 / 225], Loss: 0.47316857698288833, Validation Loss: 0.5568574070930481\n", + "Epoch [2 / 10], Step [88 / 225], Loss: 0.43606940572234715, Validation Loss: 0.5899128615856171\n", + "Epoch [2 / 10], Step [110 / 225], Loss: 0.3954015533355149, Validation Loss: 0.5944906234741211\n", + "Epoch [2 / 10], Step [132 / 225], Loss: 0.35609302819339617, Validation Loss: 0.537044107913971\n", + "Epoch [2 / 10], Step [154 / 225], Loss: 0.33128390105610545, Validation Loss: 0.46129965216719676\n", + "Epoch [2 / 10], Step [176 / 225], Loss: 0.2998663415836001, Validation Loss: 0.40397966344607994\n", + "Epoch [2 / 10], Step [198 / 225], Loss: 0.2738230372732035, Validation Loss: 0.3590930341742933\n", + "Epoch [2 / 10], Step [220 / 225], Loss: 0.25180305100300093, Validation Loss: 0.32318373075686396\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch [3 / 10], Step [22 / 225], Loss: 0.059888842261650345, Validation Loss: 0.055629707872867584\n", + "Epoch [3 / 10], Step [44 / 225], Loss: 0.0569748023355549, Validation Loss: 0.04963332414627075\n", + "Epoch [3 / 10], Step [66 / 225], Loss: 0.055947076359933075, Validation Loss: 0.033088882764180504\n", + "Epoch [3 / 10], Step [88 / 225], Loss: 0.05491821848872033, Validation Loss: 0.024816662073135376\n", + "Epoch [3 / 10], Step [110 / 225], Loss: 0.05447610897774046, Validation Loss: 0.0198533296585083\n", + "Epoch [3 / 10], Step [132 / 225], Loss: 0.08655590160439412, Validation Loss: 0.019558300574620564\n", + "Epoch [3 / 10], Step [154 / 225], Loss: 0.10329984067999698, Validation Loss: 0.0819279168333326\n", + "Epoch [3 / 10], Step [176 / 225], Loss: 0.10512340995906429, Validation Loss: 0.07168692722916603\n", + "Epoch [3 / 10], Step [198 / 225], Loss: 0.11643278070095212, Validation Loss: 0.07727163698938158\n", + "Epoch [3 / 10], Step [220 / 225], Loss: 0.11402303913438862, Validation Loss: 0.08088884353637696\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch [4 / 10], Step [22 / 225], Loss: 0.18842411464588207, Validation Loss: 0.023324092850089073\n", + "Epoch [4 / 10], Step [44 / 225], Loss: 0.1356671079146591, Validation Loss: 0.011662046425044537\n", + "Epoch [4 / 10], Step [66 / 225], Loss: 0.1225995806920709, Validation Loss: 0.007774697616696358\n", + "Epoch [4 / 10], Step [88 / 225], Loss: 0.10794795511967757, Validation Loss: 0.013592265080660582\n", + "Epoch [4 / 10], Step [110 / 225], Loss: 0.10796696299856359, Validation Loss: 0.011201474699191749\n", + "Epoch [4 / 10], Step [132 / 225], Loss: 0.10170525907905716, Validation Loss: 0.009334562249326458\n", + "Epoch [4 / 10], Step [154 / 225], Loss: 0.09754940814205579, Validation Loss: 0.020729850894505426\n", + "Epoch [4 / 10], Step [176 / 225], Loss: 0.0919922092209824, Validation Loss: 0.019730244923266582\n", + "Epoch [4 / 10], Step [198 / 225], Loss: 0.08834527585316788, Validation Loss: 0.09797394703814967\n", + "Epoch [4 / 10], Step [220 / 225], Loss: 0.0907003279775381, Validation Loss: 0.0924123348086141\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch [5 / 10], Step [22 / 225], Loss: 0.11004065857692198, Validation Loss: 0.20903348922729492\n", + "Epoch [5 / 10], Step [44 / 225], Loss: 0.10677469699558886, Validation Loss: 0.12623683735728264\n", + "Epoch [5 / 10], Step [66 / 225], Loss: 0.09529317644509402, Validation Loss: 0.08415789157152176\n", + "Epoch [5 / 10], Step [88 / 225], Loss: 0.08533265437422828, Validation Loss: 0.06311841867864132\n", + "Epoch [5 / 10], Step [110 / 225], Loss: 0.07885887971655889, Validation Loss: 0.05049473494291305\n", + "Epoch [5 / 10], Step [132 / 225], Loss: 0.0739773078398271, Validation Loss: 0.04207894578576088\n", + "Epoch [5 / 10], Step [154 / 225], Loss: 0.07347074192162457, Validation Loss: 0.07647624505417687\n", + "Epoch [5 / 10], Step [176 / 225], Loss: 0.07329438135705212, Validation Loss: 0.09326270315796137\n", + "Epoch [5 / 10], Step [198 / 225], Loss: 0.07185688417292002, Validation Loss: 0.08290018058485454\n", + "Epoch [5 / 10], Step [220 / 225], Loss: 0.07738829492167994, Validation Loss: 0.0746101625263691\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGwCAYAAABVdURTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABkjUlEQVR4nO3dd3hUVf7H8ffMJJNeKUmAQOjSkR5iAUHBguLqgog0e8O+tlXRdX9i2XWxYJdmoSrKLgIiKgqEGhCQokBIKEno6XXm/v6YEAgkIYFkJjP5vJ5nHmbuPXPnex1DPpx77jkmwzAMRERERDyE2dUFiIiIiFQnhRsRERHxKAo3IiIi4lEUbkRERMSjKNyIiIiIR1G4EREREY+icCMiIiIexcvVBTib3W7n4MGDBAUFYTKZXF2OiIiIVIJhGGRmZtKoUSPM5or7ZupcuDl48CDR0dGuLkNERETOw759+2jSpEmFbepcuAkKCgIc/3GCg4NdXI2IiIhURkZGBtHR0SW/xytS58LNyUtRwcHBCjciIiJupjJDSjSgWERERDyKwo2IiIh4FIUbERER8Sh1bsyNiIh4FpvNRmFhoavLkGpgtVrPeZt3ZSjciIiIWzIMg9TUVE6cOOHqUqSamM1mmjdvjtVqvaDjKNyIiIhbOhlsGjZsiL+/vyZmdXMnJ9lNSUmhadOmF/R9KtyIiIjbsdlsJcGmXr16ri5HqkmDBg04ePAgRUVFeHt7n/dxXDqg+JdffmHIkCE0atQIk8nEN998c873/Pzzz3Tr1g0fHx9atWrFtGnTarxOERGpXU6OsfH393dxJVKdTl6OstlsF3Qcl4ab7OxsunTpwuTJkyvVPjExkWuvvZb+/fuzadMmHnnkEe68806WLFlSw5WKiEhtpEtRnqW6vk+XXpa6+uqrufrqqyvd/oMPPqB58+b8+9//BqBdu3asWLGC//znPwwaNKjM9+Tn55Ofn1/yOiMj48KKLo/dBkmrICsNAiOgWV8wW2rms0RERKRcbjXmJj4+noEDB5baNmjQIB555JFy3zNx4kReeumlmi1s2wJY/BRkHDy1LbgRDH4N2l9fs58tIiIipbjVJH6pqalERESU2hYREUFGRga5ubllvueZZ54hPT295LFv377qLWrbApgzunSwAchIcWzftqB6P09ERKqVzW4Qv/so3246QPzuo9jshqtLqrKYmBgmTZrk6jJqDbfquTkfPj4++Pj41MzB7TZHjw1l/SAYgAkWPw0XXatLVCIitdDirSm89N9tpKTnlWyLCvFlwpD2DO4YVe2fd64xJRMmTODFF1+s8nHXrVtHQEDAeVbl0K9fP7p27eoRIcmtwk1kZCRpaWmltqWlpREcHIyfn5/zC0padXaPTSkGZBxwtGt+qdPKEhGRc1u8NYX7Pk8465+nqel53Pd5Au/f1q3aA05KSkrJ89mzZ/PCCy+wc+fOkm2BgYElzw3DwGaz4eV17l/VDRo0qNY63Z1bXZaKjY1l2bJlpbYtXbqU2NhY1xSUlXbuNlVpJyIi580wDHIKiir1yMwrZMKC38vtdwd4ccE2MvMKK3U8w6jcpazIyMiSR0hICCaTqeT1jh07CAoKYtGiRXTv3h0fHx9WrFjB7t27ueGGG4iIiCAwMJCePXvyww8/lDrumZelTCYTn3zyCTfeeCP+/v60bt2aBQsubJjEV199RYcOHfDx8SEmJqbk5p6T3nvvPVq3bo2vry8RERHcfPPNJfvmzZtHp06d8PPzo169egwcOJDs7OwLqqciLu25ycrKYteuXSWvExMT2bRpE+Hh4TRt2pRnnnmGAwcOMGPGDADuvfde3n33XZ588kluv/12fvzxR+bMmcPChQtdcwKBEeduU5V2IiJy3nILbbR/oXqmBjGA1Iw8Or34faXab/vHIPyt1fMr9emnn+Zf//oXLVq0ICwsjH379nHNNdfwf//3f/j4+DBjxgyGDBnCzp07adq0abnHeemll3j99dd54403eOeddxg5ciRJSUmEh4dXuaYNGzYwbNgwXnzxRYYPH86qVau4//77qVevHmPHjmX9+vU89NBDfPbZZ/Tt25djx47x66+/Ao7eqhEjRvD6669z4403kpmZya+//lrpQHg+XBpu1q9fT//+/UteP/bYYwCMGTOGadOmkZKSQnJycsn+5s2bs3DhQh599FHeeustmjRpwieffFLubeA1rllfCG6EkZGCqYz8b2DCFNzI0U5ERKQS/vGPf3DllVeWvA4PD6dLly4lr19++WXmz5/PggULePDBB8s9ztixYxkxYgQAr7zyCm+//TZr165l8ODBVa7pzTffZMCAATz//PMAtGnThm3btvHGG28wduxYkpOTCQgI4LrrriMoKIhmzZpx8cUXA45wU1RUxF/+8heaNWsGQKdOnapcQ1W4NNz069evwuRW1uzD/fr1Y+PGjTVYVRWYLWzs8DRdVj2EAZhPGydmGGBgsKnDU1yswcQiIjXOz9vCtn9U7h+7axOPMXbqunO2mzauJ72an7unw8+7+v6e79GjR6nXWVlZvPjiiyxcuLAkKOTm5pb6x39ZOnfuXPI8ICCA4OBgDh06dF41bd++nRtuuKHUtri4OCZNmoTNZuPKK6+kWbNmtGjRgsGDBzN48OCSS2JdunRhwIABdOrUiUGDBnHVVVdx8803ExYWdl61VIZbjbmpbWx2g/sTmnBf4SOkcvb//M8U3sX9CU3c8rZCERF3YzKZ8Ld6VepxaesGRIX4Ut69SyYcd01d2rpBpY5XnTMln3nX0xNPPMH8+fN55ZVX+PXXX9m0aROdOnWioKCgwuOcuTaTyWTCbrdXW52nCwoKIiEhgZkzZxIVFcULL7xAly5dOHHiBBaLhaVLl7Jo0SLat2/PO++8Q9u2bUlMTKyRWkDh5oKsTTxGSnoeS+y9uCT/bW4peI6HCh5kmz0akwmam1NJSc9jbeIxV5cqIiKnsZhNTBjSHuCsgHPy9YQh7bGYXb+8w8qVKxk7diw33ngjnTp1IjIykr179zq1hnbt2rFy5cqz6mrTpg0Wi6PXysvLi4EDB/L666+zefNm9u7dy48//gg4glVcXBwvvfQSGzduxGq1Mn/+/Bqr161uBa9tDmWemhfBjpnVdscPSlaRL1Os/+JWyw9MLrqhVDsREakdBneM4v3bup01z01kDc5zcz5at27N119/zZAhQzCZTDz//PM11gNz+PBhNm3aVGpbVFQUjz/+OD179uTll19m+PDhxMfH8+677/Lee+8B8L///Y89e/Zw2WWXERYWxnfffYfdbqdt27asWbOGZcuWcdVVV9GwYUPWrFnD4cOHadeuXY2cAyjcXJCGQb5lbv/J3pU/7I1pYz7ACMsyGgZd4eTKRESkMgZ3jOLK9pGsTTzGocw8Ggb50qt5eK3osTnpzTff5Pbbb6dv377Ur1+fp556qsbWSfzyyy/58ssvS217+eWXee6555gzZw4vvPACL7/8MlFRUfzjH/9g7NixAISGhvL111/z4osvkpeXR+vWrZk5cyYdOnRg+/bt/PLLL0yaNImMjAyaNWvGv//97yqtLVlVJqMm78WqhTIyMggJCSE9PZ3g4OALOpbNbnDJaz+Smp531r1SN1uW8y/vDzlMOOHPbsdiLTsIiYhI1eXl5ZGYmEjz5s3x9dXfr56iou+1Kr+/NebmAlR0zfZbWxypRhgNOIbl93nOL05ERKSOUri5QCev2UaGlE6YhXhxqP3tjhcr34Yauj4qIiIipSncVIPBHaNY8dQVzLyrD28N70pMPX8A1tW/AXyC4chO+LN6Zs0UERGRiincVBOL2URsy3rccHFj7u/XCoAp645i736y9+YtF1YnIiJSdyjc1IDruzYi1N+bAydyWVHvJrBYITkekte4ujQRERGPp3BTA3y9LQzvGQ3Ax5tyofNwx45Vb7uwKhERkbpB4aaG3Na7GSYT/PrnEZIuutOxccdCOPKnawsTERHxcAo3NSQ63J8BF0UAMGWHF7S9FjBg1TuuLUxERMTDKdzUoDF9HUu7z9uwn+yeDzg2/jYTMtNcWJWIiLi7fv368cgjj7i6jFpL4aYGXdKqPi0aBJBdYOOrw40hujfYCmDNB64uTURETrLbIPFX2DLP8afdVmMfNWTIEAYPHlzmvl9//RWTycTmzZsv+HOmTZtGaGjoBR/HXSnc1CCTycSY2BgApq/ai9H3IceOdZ9CfqbrChMREYdtC2BSR5h+HXx1h+PPSR0d22vAHXfcwdKlS9m/f/9Z+6ZOnUqPHj3o3LlzjXx2XaJwU8P+0q0xAVYLuw9ns9LSC+q1hvx02DDd1aWJiNRt2xbAnNGQcbD09owUx/YaCDjXXXcdDRo0YNq0aaW2Z2VlMXfuXO644w6OHj3KiBEjaNy4Mf7+/nTq1ImZM2dWax3JycnccMMNBAYGEhwczLBhw0hLOzVk4rfffqN///4EBQURHBxM9+7dWb9+PQBJSUkMGTKEsLAwAgIC6NChA99991211nehFG5qWJCvNzd1bwLA9NXJEFfce7P6PSgqcGFlIiIexjCgILtyj7wMWPQknLXsMae2LX7K0a4yx6vkGtReXl6MHj2aadOmcfq61XPnzsVmszFixAjy8vLo3r07CxcuZOvWrdx9992MGjWKtWvXXvh/I8But3PDDTdw7Ngxli9fztKlS9mzZw/Dhw8vaTNy5EiaNGnCunXr2LBhA08//TTe3t4APPDAA+Tn5/PLL7+wZcsWXnvtNQIDA6ulturi5eoC6oLRsc2YEZ/Esu1p7Bs8hOjAf0LGAdj6FXQd4eryREQ8Q2EOvNKomg5mOHp0Xo2uXPNnD4I1oFJNb7/9dt544w2WL19Ov379AMclqZtuuomQkBBCQkJ44oknStqPHz+eJUuWMGfOHHr16lXVEznLsmXL2LJlC4mJiURHO85vxowZdOjQgXXr1tGzZ0+Sk5P529/+xkUXXQRA69atS96fnJzMTTfdRKdOnQBo0aLFBddU3dRz4wStGgZxSav62A34YkMa9LnPsWPlW5VO+yIi4hkuuugi+vbty5QpUwDYtWsXv/76K3fccQcANpuNl19+mU6dOhEeHk5gYCBLliwhOTm5Wj5/+/btREdHlwQbgPbt2xMaGsr27dsBeOyxx7jzzjsZOHAgr776Krt37y5p+9BDD/HPf/6TuLg4JkyYUC0DoKubem6cZHRsM1bsOsLsdck88ugYfH/5NxzeDn8uhTZXubo8ERH35+3v6EGpjKRV8MXN5243ch4061u5z66CO+64g/HjxzN58mSmTp1Ky5YtufzyywF44403eOutt5g0aRKdOnUiICCARx55hIIC5w1lePHFF7n11ltZuHAhixYtYsKECcyaNYsbb7yRO++8k0GDBrFw4UK+//57Jk6cyL///W/Gjx/vtPrORT03TjKgXQSNQ/04nlPIgp3Z0GOsY4cW1BQRqR4mk+PSUGUeLa+A4EaAqbyDQXBjR7vKHM9U3nHKNmzYMMxmM19++SUzZszg9ttvx1R8jJUrV3LDDTdw22230aVLF1q0aMEff/xxYf9tTtOuXTv27dvHvn37SrZt27aNEydO0L59+5Jtbdq04dFHH+X777/nL3/5C1OnTi3ZFx0dzb333svXX3/N448/zscff1xt9VUHhRsnsZhN3NbHManf9FV7MXrfC2ZvSFoB+ze4uDoRkTrGbIHBrxW/ODOYFL8e/KqjXQ0IDAxk+PDhPPPMM6SkpDB27NiSfa1bt2bp0qWsWrWK7du3c88995S6k6mybDYbmzZtKvXYvn07AwcOpFOnTowcOZKEhATWrl3L6NGjufzyy+nRowe5ubk8+OCD/PzzzyQlJbFy5UrWrVtHu3btAHjkkUdYsmQJiYmJJCQk8NNPP5Xsqy0UbpxoeM9orF5mfj+YQcKJAOg8zLFjlXpvREScrv31MGwGBEeV3h7cyLG9/fU1+vF33HEHx48fZ9CgQTRqdGog9HPPPUe3bt0YNGgQ/fr1IzIykqFDh1b5+FlZWVx88cWlHkOGDMFkMvHtt98SFhbGZZddxsCBA2nRogWzZ88GwGKxcPToUUaPHk2bNm0YNmwYV199NS+99BLgCE0PPPAA7dq1Y/DgwbRp04b33nuvWv6bVBeTYdStEa0ZGRmEhISQnp5OcHCw0z//b3N/Y+6G/dzQtRFvXeEL7/UBTDB+A9Rr6fR6RETcUV5eHomJiTRv3hxfX98LO5jd5hiDk5UGgRGOMTY11GMjFavoe63K72/13DjZmL4xAHy3JYVDfs2hzWDAgPh3XVqXiEidZbZA80uh082OPxVs3J7CjZN1bBxCt6ahFNoMZq7ZByeXZNj4BWQdcm1xIiIiHkDhxgVO9t58sSaJwiZ9oHEPsOXD2o9cW5iIiIgHULhxgas7RlE/0IdDmfks2ZYGcQ87dqz9GPKzXFuciIiIm1O4cQGrl5lbezcFYMaqJLjoWghvCXknYONnri1ORMSN1LF7YjxedX2fCjcuMrJ3U7zMJtbuPca21GzoWzyzY/xksBW6tjgRkVru5CKOOTk5Lq5EqtPJWZgtlgsb1K3lF1wkItiXQR0jWbg5hRnxe3n1+hHw0/9B+j74ff6pOXBEROQsFouF0NBQDh1y3Ijh7+9fMsOvuCe73c7hw4fx9/fHy+vC4onCjQuNiY1h4eYUvtl0gKevvojQ3vfCjy87lmTo9NcqT+ctIlKXREZGApQEHHF/ZrOZpk2bXnBQVbhxoZ4xYVwUGcSO1Ezmrt/PXT3vgF/fhLStsHsZtBro6hJFRGotk8lEVFQUDRs2pLBQl/M9gdVqxWy+8BEzCjcuZDKZGNs3hqe/3sJnq5O4/ZLmWLqPhdWTHb03CjciIudksVgueIyGeBYNKHaxG7o2JtjXi+RjOfy88xD0uQ/MXpD4Cxzc6OryRERE3I7CjYv5WS0M7xkNwPT4JAiNho43O3aufNuFlYmIiLgnhZta4LY+zTCZ4Jc/DrPncBbEFS/JsO0bOJbo0tpERETcjcJNLdCsXgD92zYE4LPVSRDRwTHexrA75r0RERGRSlO4qSVOrjc1b/1+svOLTi3JsPFzyD7iusJERETcjMJNLXFpq/o0rx9AZn4RX288ADGXQqOLoSjXseaUiIiIVIrCTS1hNpsY1acZADNW7cWA0xbU/AgKsl1Wm4iIiDtRuKlFbu7RBH+rhT8PZRG/5yi0ux7CYiD3GGz8wtXliYiIuAWFm1ok2Nebv3RrDBSvFm62nLag5jtgK3JhdSIiIu5B4aaWGR0bA8D321I5cCIXuo4E//pwItlxa7iIiIhUSOGmlmkTEURsi3rYDfhidRJ4+0Hvexw7V74FhuHaAkVERGo5hZtaaExfx8DiWev2kVdog553grc/pG6GPT+7tjgREZFaTuGmFhrYLoJGIb4cyy5g4eYU8A+HbqMdO1dpSQYREZGKKNzUQl4WMyNP3hYev9exsc/9YLLA7h8hZbPrihMREanlFG5qqVt6RmO1mPltfzqb9p2AsGbQ8S+Oneq9ERERKZfCTS1VL9CH67pEATB91V7Hxr7FC2pu/RqOJ7mmMBERkVpO4aYWG1N8W/jCzSkczsyHqM7Qoj8YNlj9nmuLExERqaUUbmqxLtGhdIkOpcBmZ/a6ZMfGk0syJMyAnGOuK05ERKSWUrip5cYW3xb++epkimx2aNEPIjtDYQ6s+8S1xYmIiNRCCje13DWdoqgXYCU1I4+l29LAZDrVe7PmAyjMdW2BIiIitYzCTS3n42VhRK+mAEw7ObC4/VAIbQo5R2GTFtQUERE5ncKNG7i1d1MsZhNrEo+xIzUDLF4QW7yg5qp3wG5zbYEiIiK1iMKNG2gU6sdV7SMAmBFffAv4xSPBLxyO74XtC1xXnIiISC2jcOMmxvSNAWB+wgHScwvBGgC97nbsXPm2FtQUEREppnDjJno3D6dtRBC5hTbmrt/n2NjrLvDyg4MJsHeFawsUERGpJRRu3ITJZGJ08W3hn61Owm43IKA+XHybo8HKt1xYnYiISO2hcONGhnZtTJCvF0lHc1j+52HHxtgHwGSGXUshdatrCxQREakFXB5uJk+eTExMDL6+vvTu3Zu1a9dW2H7SpEm0bdsWPz8/oqOjefTRR8nLy3NSta4V4OPFX7tHAzDj5G3h4c2h/Q2O56vecU1hIiIitYhLw83s2bN57LHHmDBhAgkJCXTp0oVBgwZx6NChMtt/+eWXPP3000yYMIHt27fz6aefMnv2bJ599lknV+46o2Mdl6Z+/uMwe49kOzaWLKg5D07sc1FlIiIitYNLw82bb77JXXfdxbhx42jfvj0ffPAB/v7+TJkypcz2q1atIi4ujltvvZWYmBiuuuoqRowYcc7eHk8SUz+Afm0bYBiOsTcANO4GzS8DexGsft+1BYqIiLiYy8JNQUEBGzZsYODAgaeKMZsZOHAg8fHxZb6nb9++bNiwoSTM7Nmzh++++45rrrmm3M/Jz88nIyOj1MPdnVwtfM76feQUFDk2nlySYcM0yD3ukrpERERqA5eFmyNHjmCz2YiIiCi1PSIigtTU1DLfc+utt/KPf/yDSy65BG9vb1q2bEm/fv0qvCw1ceJEQkJCSh7R0dHVeh6ucHmbBjSr509mXhHfbDzo2NhyAER0hMJsWPepawsUERFxIZcPKK6Kn3/+mVdeeYX33nuPhIQEvv76axYuXMjLL79c7nueeeYZ0tPTSx779rn/mBSz2cSoPo6xNzPi92IYRhkLataNQdYiIiJnclm4qV+/PhaLhbS0tFLb09LSiIyMLPM9zz//PKNGjeLOO++kU6dO3HjjjbzyyitMnDgRu91e5nt8fHwIDg4u9fAEf+0ejZ+3hR2pmaxNPObY2OFGCImG7MPw20zXFigiIuIiLgs3VquV7t27s2zZspJtdrudZcuWERsbW+Z7cnJyMJtLl2yxWAAcvRd1SIi/N0MvbgzA9Pi9jo0Wb8e8N6AFNUVEpM5y6WWpxx57jI8//pjp06ezfft27rvvPrKzsxk3bhwAo0eP5plnnilpP2TIEN5//31mzZpFYmIiS5cu5fnnn2fIkCElIacuOXlb+JLf00hJz3VsvHgU+IbCsd2w8zvXFSciIuIiXq788OHDh3P48GFeeOEFUlNT6dq1K4sXLy4ZZJycnFyqp+a5557DZDLx3HPPceDAARo0aMCQIUP4v//7P1edgku1iwqmV/Nw1iYe48s1yTx+VVvwCXSsOfXLG7BiElx0nWM8joiISB1hMurY9ZyMjAxCQkJIT0/3iPE3321J4f4vEqgfaGXl01fg42WBrMPwnw5gy4dxi6BZX1eXKSIickGq8vvbre6WkrNd2T6CyGBfjmQVsGhL8S30gQ2g662O51pQU0RE6hiFGzfnbTEzsndTAKadXG8KoO94wAR/LIZD211Sm4iIiCso3HiAW3o1xdtiYtO+E/y274RjY72W0G6I47kW1BQRkTpE4cYDNAjy4dpOUQDMiE86tePkpH6b50D6ARdUJiIi4nwKNx5iTN8YAP67+SBHs/IdG5v0gGaXgL0Q1mhBTRERqRsUbjxE1+hQOjcJoaDIzuz1py0xcbL3Zv00yD3hitJEREScSuHGQ5hMJkYXrxb+eXwSRbbi5ShaXwkN20NBJmyY6roCRUREnEThxoNc1zmKMH9vDqbn8cP2Q46NJhP0fcjxfPX7UJTvugJFREScQOHGg/h6W7ill+O28Bkn15sC6HgTBDeGrDTYPNs1xYmIiDiJwo2Hua1PM8wmWLX7KH+mZTo2elmhz/2O56vegXJWUBcREfEECjcepnGoH1e2d6zNVeq28O5jwCcEjvzhmNhPRETEQynceKAxxQOLv0rYT0ZeoWOjTxD0vMPxXEsyiIiIB1O48UCxLevRqmEgOQU2vtqw/9SO3veAxQr7VkPyatcVKCIiUoMUbjyQyWRiTGwzAD6LT8JuL174PSgSutzieL7ybRdVJyIiUrMUbjzUX7o1IcjHiz1Hslmx68ipHX0fAkywcyEc/sNl9YmIiNQUhRsPFeDjxU3dmwAw/fTVwuu3houudTxfpd4bERHxPAo3HmxU8aWpH3ceIvlozqkdJQtqzoaMFBdUJiIiUnMUbjxYywaBXNq6PoYBn6857bbw6F7QNBZsBbDmA9cVKCIiUgMUbjzcydvCZ6/bR26B7dSOkgU1p0BehvMLExERqSEKNx6u/0UNiQ73Iz23kAW/HTi1o/UgqN8W8jNgwzSX1SciIlLdFG48nMVsYlQfx9ibaauSMIzi28LNZog7fUHNAhdVKCIiUr0UbuqAYT2i8fEysz0lg/VJx0/t6PRXCIqCzIOwdZ7rChQREalGCjd1QKi/laFdGwNn3Bbu5QN97nM8X/m2FtQUERGPoHBTR4zu67g0tXhrKmkZead2dB8LPsFweDvsWuqa4kRERKqRwk0d0aFRCD1jwiiyG3y5JvnUDt8QR8ABLagpIiIeQeGmDhldfFv4l2uTKSg67RJUn/vA7A1JK2HfOtcUJyIiUk0UbuqQQR0iaRjkw+HMfBZtPW1m4uBG0Hm44/kq9d6IiIh7U7ipQ6xeZm7t3RSAGfFJpXf2He/4c/v/4MguJ1cmIiJSfRRu6phbezfF22JiQ9Jxth5IP7Wj4UXQ5mrAgPh3XFafiIjIhVK4qWMaBvlydccoAGbE7y298+SSDJtmQmaacwsTERGpJgo3ddCY4tvCv910kOPZp81M3LQPNOkFtnxY+6GLqhMREbkwCjd1ULemYXRoFEx+kZ3Z6/ed2mEyneq9WfcJ5Ge6pkAREZELoHBTB5lMppLVwj+LT8JmN07tbHsN1GsFeemQ8JlrChQREbkACjd11PVdGxHq782BE7n8uOPQqR1mM/QtXlAzfjLYCl1ToIiIyHlSuKmjfL0tDO8ZDZQxsLjzcAiMgIz9sPVr5xcnIiJyARRu6rDbejfDZIJf/zzCrkNZp3Z4+0Lvex3PV74FhlH2AURERGohhZs6LDrcnwEXRQDw2Zm9Nz1uB2sgHPoddi1zfnEiIiLnSeGmjjt5W/i8DfvJzDttfI1f6GkLak5ydlkiIiLnTeGmjrukVX1aNAggu8DG/I0HSu/scx+YvWDvr3Bgg2sKFBERqSKFmzru9NvCp6/ai3H6+JqQJtDpr47nK992fnEiIiLnQeFG+Eu3xgRYLew+nM3KXUdL7yxZUHMBHN3t/OJERESqSOFGCPL15qbuTQCYfubA4ogO0PoqMOyOeW9ERERqOYUbAWB0rGNg8bLtaew7llN6Z8mCml9A1mEnVyYiIlI1CjcCQKuGQVzSqj52A75Yk1x6Z7M4aNwdivJg7UeuKVBERKSSFG6kxMnem1nrkskrtJ3aUWpBzY+hINsF1YmIiFSOwo2UGNAugsahfpzIKWTBbwdL77zoOghvAbnHYePnrilQRESkEhRupITFbOK2Po7em7NuCzdbTt05tepdsBW5oEIREZFzU7iRUm7pGY2Pl5nfD2aQkHyi9M4uIyCgAaQnw7ZvXFGeiIjIOSncSClhAVau79IIKGO1cG8/6HWP4/nKSVpQU0REaiWFGznLmL4xAHy3JYVDmXmld/a8A7z9IXUL7PnJ+cWJiIicg8KNnKVj4xC6NQ2l0GYwc82+0jv9w6HbGMfzlW85vzgREZFzULiRMp3svfliTRKFNnvpnbH3g8kCe36Gg5ucXZqIiEiFFG6kTFd3jKJ+oA+HMvNZ8ntq6Z2hTaHjTY7nq7SgpoiI1C4KN1Imq5eZW3s3BWDGqqSzG8Q95Pjz9/lwfK/zChMRETkHhRsp18jeTfEym1i79xjbDmaU3hnZCVoO0IKaIiJS6yjcSLkign0Z1DESKOO2cDi1JEPCZ5B91HmFiYiIVEDhRio0JjYGgG82HeBETkHpnc0vg6iuUJQL6z5xem0iIiJlqXK4Wbx4MStWrCh5PXnyZLp27cqtt97K8ePHq7U4cb2eMWG0iwomr9DO3PX7S+88fUHNtR9CQY7zCxQRETlDlcPN3/72NzIyHOMvtmzZwuOPP84111xDYmIijz32WLUXKK5lMpkYU7xa+Gerk7DZz5iVuN31EBYDOUdh0xfOL1BEROQMVQ43iYmJtG/fHoCvvvqK6667jldeeYXJkyezaNGiai9QXO+Gro0J9vUi+VgOP+88VHqnxQtiH3Q8j9eCmiIi4npVDjdWq5WcHMflhx9++IGrrroKgPDw8JIeHfEsflYLw3tGAzA9vozbwruOBP96jlvCty9wbnEiIiJnqHK4ueSSS3jsscd4+eWXWbt2Lddeey0Af/zxB02aNKn2AqV2GNUnBpMJfvnjMHsOZ5XeafWHXnc7nq98SwtqioiIS1U53Lz77rt4eXkxb9483n//fRo3bgzAokWLGDx4cJULmDx5MjExMfj6+tK7d2/Wrl1bYfsTJ07wwAMPEBUVhY+PD23atOG7776r8udK1TSt588VbRsCjrE3Z+l5F3j5QcomSPzFucWJiIicxmQYrvtn9uzZsxk9ejQffPABvXv3ZtKkScydO5edO3fSsGHDs9oXFBQQFxdHw4YNefbZZ2ncuDFJSUmEhobSpUuXSn1mRkYGISEhpKenExwcXN2n5NGW/3GYMVPWEuTjxepnBxDg41W6wXd/g7UfOSb3G/W1a4oUERGPVJXf31XuuUlISGDLli0lr7/99luGDh3Ks88+S0FBQQXvPNubb77JXXfdxbhx42jfvj0ffPAB/v7+TJkypcz2U6ZM4dixY3zzzTfExcURExPD5ZdfXulgIxfm0lb1aV4/gMz8Ir7eeODsBrEPgMkMu5dB6paz94uIiDhBlcPNPffcwx9//AHAnj17uOWWW/D392fu3Lk8+eSTlT5OQUEBGzZsYODAgaeKMZsZOHAg8fHxZb5nwYIFxMbG8sADDxAREUHHjh155ZVXsNls5X5Ofn4+GRkZpR5yfsxmE6P6OG4Ln7FqL2d1+oXFQIcbHc9XakFNERFxjSqHmz/++IOuXbsCMHfuXC677DK+/PJLpk2bxldffVXp4xw5cgSbzUZERESp7REREaSmppb5nj179jBv3jxsNhvfffcdzz//PP/+97/55z//We7nTJw4kZCQkJJHdHR0pWuUs93cown+Vgt/Hsoifk8ZSy70LV5Qc+tXcCLZucWJiIhwHuHGMAzsdjvguBX8mmuuASA6OpojR45Ub3VnsNvtNGzYkI8++oju3bszfPhw/v73v/PBBx+U+55nnnmG9PT0kse+fftqtEZPF+zrzV+6OQaRl7laeKOu0KIfGDZY/b5TaxMREYHzCDc9evTgn//8J5999hnLly8vuRU8MTHxrF6YitSvXx+LxUJaWlqp7WlpaURGRpb5nqioKNq0aYPFYinZ1q5dO1JTU8sd7+Pj40NwcHCph1yY0cXrTX2/LZUDJ3LPbnBySYYN0yHnmPMKExER4TzCzaRJk0hISODBBx/k73//O61atQJg3rx59O3bt9LHsVqtdO/enWXLlpVss9vtLFu2jNjY2DLfExcXx65du0p6jsBxmSwqKgqr1VrVU5Hz1CYiiNgW9bAb8EVZt4W36A+RnaAwG9Z/6vwCRUSkTqu2W8Hz8vKwWCx4e3tX+j2zZ89mzJgxfPjhh/Tq1YtJkyYxZ84cduzYQUREBKNHj6Zx48ZMnDgRgH379tGhQwfGjBnD+PHj+fPPP7n99tt56KGH+Pvf/16pz9St4NVj8dYU7v08gfAAK6uevgJfb0vpBlvmwVd3QEADeGQLePu5plAREfEIVfn97VXh3gps2LCB7du3A9C+fXu6detW5WMMHz6cw4cP88ILL5CamkrXrl1ZvHhxyeWt5ORkzOZTnUvR0dEsWbKERx99lM6dO9O4cWMefvhhnnrqqfM9DTlPA9tF0CjEl4PpeSzcnMJN3c+Ynbr9UPjhJUhPht9mQo/bXVKniIjUPVXuuTl06BDDhw9n+fLlhIaGAo5Zg/v378+sWbNo0KBBTdRZbdRzU30m/7SLN5bspEuTEL598JKzG6z+ABY/BeEt4MH1YLac3UZERKQSanQSv/Hjx5OVlcXvv//OsWPHOHbsGFu3biUjI4OHHnrovIsW93NLz2isFjO/7U9nY/Lxsxt0GwV+YXBsD+z4n/MLFBGROqnK4Wbx4sW89957tGvXrmRb+/btmTx5MosWLarW4qR2qxfow3VdogCYUdZq4dYAx5pTACsmaUFNERFxiiqHG7vdXuagYW9v71J3MUndMKb4tvCFm1M4nJl/doNed4OXLxxMgKSVzi1ORETqpCqHmyuuuIKHH36YgwcPlmw7cOAAjz76KAMGDKjW4qT26xIdStfoUApsdmavK2NG4sAG0HWk4/nKt5xbnIiI1ElVDjfvvvsuGRkZxMTE0LJlS1q2bEnz5s3JyMjg7be1nlBdNKavY72pz1cnU2Qro/fu5IKaf34Pab87uToREalrqnwreHR0NAkJCfzwww/s2LEDcMwSfPoCmFK3XNMpin/+bzupGXl8vy2NazpFlW5QryW0ux62fQOr3oEby18uQ0RE5EJVuecGwGQyceWVVzJ+/HjGjx/PwIED2bFjB23atKnu+sQN+HhZGNGrKQDTV+0tu1Fc8Z10W+ZC+gHnFCYiInXSeYWbsuTn57N79+7qOpy4mZF9mmIxm1iTeIwdqRlnN2jcHWIuBXsRrH7P+QWKiEidUW3hRuq2qBA/BnVwzCxd5m3hAHGPOP7cMA1yTzijLBERqYMUbqTanFwtfH7CAdJzC89u0GoANOwABVmwfopzixMRkTpD4UaqTe/m4bSNCCK30Mbc9fvObmAyQdzDjudrPoDCPOcWKCIidUKlw01YWBjh4eHlPi699NKarFPcgMlkYnTxbeGfrU7Cbi9jRuKOf4HgJpCVBptnO7lCERGpCyp9K/ikSZNqsAzxFEO7NubVRTtIOprD8j8P079tw9INLN4Qez8seRZWvQ0XjwKzOhBFRKT6VDrcjBkzpibrEA8R4OPFsB7RfLoikRmr9p4dbgC6jYblr8HRXbDzO2h3nfMLFRERj6V/Mku1G9XHcWnq5z8Os/dI9tkNfIKg552O5ysnaUFNERGpVgo3Uu1i6gfQr20DDMMx9qZMve4Biw/sXwfJq51boIiIeDSFG6kRJ1cLn7N+HzkFRWc3CIqAriMcz7WgpoiIVCOFG6kRl7dpQLN6/mTmFfHNxoNlN4odD5jgj0VwaIdT6xMREc+lcCM1wmw2lYy9mRG/F6OscTX1W50aTBz/jhOrExERT1blVcFtNhvTpk1j2bJlHDp0CLvdXmr/jz/+WG3FiXv7a/do/v39H+xIzWRt4jF6t6h3dqO4R2D7f+G32dD/OQiOOruNiIhIFVS55+bhhx/m4Ycfxmaz0bFjR7p06VLqIXJSiL83Qy9uDMD0+L1lN2rSA5rFgb0Q1rzvvOJERMRjVbnnZtasWcyZM4drrrmmJuoRDzM6thkz1yaz5Pc0UtJziQrxO7tR3MOQtBLWT4VLHwffEOcXKiIiHqPKPTdWq5VWrVrVRC3igdpFBdOreTg2u8GXa5LLbtTqSmjQDvIzHCuGi4iIXIAqh5vHH3+ct956q+wBoiJlGNs3BoCZa5PJL7Kd3cBshr7jHc9Xvw9F+c4rTkREPE6VL0utWLGCn376iUWLFtGhQwe8vb1L7f/666+rrTjxDFe2jyAy2JfUjDwWbUktGYdTSqe/wo8vQ2YKbJkLF9/m/EJFRMQjVLnnJjQ0lBtvvJHLL7+c+vXrExISUuohciZvi5mRvZsCMG3V3rIbeVmhz/2O5yvfhjPuwhMREaksk1HHri9lZGQQEhJCeno6wcHBri6nzjicmU/cqz9SYLPz7QNxdIkOPbtRXgb8p4Nj7M2IWdD2aqfXKSIitVNVfn9rEj9xigZBPlzb2TGHzYz4ctab8g2GHrc7nmtJBhEROU/nFW7mzZvHsGHD6NOnD926dSv1ECnP6FjHjMX/3XyQo1nlDBrufS9YrJAcD8lrnFidiIh4iiqHm7fffptx48YRERHBxo0b6dWrF/Xq1WPPnj1cfbUuI0j5ukaH0rlJCAVFdmat21d2o+Ao6Dzc8XzV284rTkREPEaVw817773HRx99xDvvvIPVauXJJ59k6dKlPPTQQ6Snp9dEjeIhTCYTo4tXC/9idRJFtnIGDfd9yPHnjoVw5E/nFCciIh6jyuEmOTmZvn37AuDn50dmZiYAo0aNYubMmdVbnXic6zpHER5g5WB6Hj9sP1R2owZtoO21gAGrtKCmiIhUTZXDTWRkJMeOHQOgadOmrF69GoDExERN7Cfn5Ott4Zae0YBjtfByxT3s+PO3mZCZVvOFiYiIx6hyuLniiitYsGABAOPGjePRRx/lyiuvZPjw4dx4443VXqB4npF9mmE2wardR/kzLbPsRk17Q3QfsBXAmg+cW6CIiLi1Ks9zY7fbsdvteHk5JjeeNWsWq1atonXr1txzzz1YrdYaKbS6aJ6b2uGez9az5Pc0buvTlH8O7VR2ox0LYdat4BMCj/0OPkHOLVJERGqNqvz+1iR+4hKrdh3h1k/W4G+1sPrZAQT7ep/dyG6Hyb3g6J9w1f9B3wedX6iIiNQKNT6J36+//sptt91GbGwsBw4cAOCzzz5jxYoV53M4qYNiW9ajdcNAcgpsfLVhf9mNzGaIK75zavV7UFTgvAJFRMRtVTncfPXVVwwaNAg/Pz82btxIfr5jMrb09HReeeWVai9QPJPJZGJ08Wrhn8UnYbeX04HYeTgERkDGAdj6lfMKFBERt1XlcPPPf/6TDz74gI8//rjUiuBxcXEkJCRUa3Hi2f5ycWOCfLzYcySbFbuOlN3Iywf63Od4vvItqFtXUUVE5DxUOdzs3LmTyy677KztISEhnDhxojpqkjoiwMeLm7o3AWB6eauFA3QfB9YgOLwd/lzqnOJERMRtndc8N7t27Tpr+4oVK2jRokW1FCV1x6ji9aZ+3HmI5KM5ZTfyC4UeYx3PtaCmiIicQ5XDzV133cXDDz/MmjVrMJlMHDx4kC+++IInnniC++67ryZqFA/WskEgl7auj2HA52vKWS0coPd9YPaGpBWwf4PzChQREbdT5XDz9NNPc+uttzJgwACysrK47LLLuPPOO7nnnnsYP358TdQoHm5s8cDi2ev2kVtgK7tRSGPoPMzxfJV6b0REpHznPc9NQUEBu3btIisri/bt2xMYGFjdtdUIzXNT+9jsBv3+9RP7juXy2k2dGN6zadkND22H9/oAJhi/Aeq1dGqdIiLiOjU+zw2A1Wqlffv29OrVy22CjdROFrOJUX0cY2+mrUoqf42yhu2gzWDAgPh3nVegiIi4Fa/KNrz99tsr1W7KlCnnXYzUXcN6RPPv7/9ge0oG65OO0zMmvOyGcQ/DH4th4xfQ7xkIbOjcQkVEpNardM/NtGnT+Omnnzhx4gTHjx8v9yFyPkL9rQzt2hg4x23hTWOhcQ+w5cPaj5xTnIiIuJVK99zcd999zJw5k8TERMaNG8dtt91GeHg5/7oWOQ+j+zZj9vp9LN6aSlpGHhHBvmc3MpkcvTdzRsHajyHuEfDRZVERETml0j03kydPJiUlhSeffJL//ve/REdHM2zYMJYsWVL+GAmRKujQKISeMWEU2Q2+XJNcfsOLroXwlpB3AjZ+5rT6RETEPVRpQLGPjw8jRoxg6dKlbNu2jQ4dOnD//fcTExNDVlZWTdUodcjo2BgAvlybTEGRvexGZgv0LZ52IH4y2AqdU5yIiLiF875bymw2YzKZMAwDm62cuUlEqmhQh0gaBvlwODOfRVtTym/YZQQENID0ffD7fOcVKCIitV6Vwk1+fj4zZ87kyiuvpE2bNmzZsoV3332X5ORk3Q4u1cLqZebW3o55bmbEVzBjsbcv9L7X8VwLaoqIyGkqHW7uv/9+oqKiePXVV7nuuuvYt28fc+fO5ZprrsFsPu8OIJGz3Nq7Kd4WExuSjrP1QHr5DXveAd4BkLYVdi9zXoEiIlKrVXqGYrPZTNOmTbn44osxmUzltvv666+rrbiaoBmK3cNDMzey4LeDDOvRhNdv7lJ+w8XPwurJ0PxyGLPAeQWKiIhT1cgMxaNHj6Z///6EhoYSEhJS7kOkOozp65ix+NtNBzmeXVB+wz73gdkLEpfDwY1Oqk5ERGqzSs9zM23atBosQ6S0bk3D6NAomN8PZjB7/T7uvbycdaRCo6HjzbB5Fqx8G/461bmFiohIraPBMlIrmUwmxhSvFv5ZfBI2ewVXT+Mecvy57Rs4lljjtYmISO2mcCO11vVdGhHq782BE7n8uONQ+Q0jOkCrK8GwO+a9ERGROk3hRmotX28Lw3tGA+dYbwpO9d5s/Byyj9RsYSIiUqsp3EitdlvvZphMsGLXEXYdyiy/Ycyl0OhiKMp1rDklIiJ1lsKN1GrR4f4MuCgCcIy9KdfJBTXBsVp4QbYTqhMRkdpI4UZqvbHFA4vnbdhPZl4F60i1ux7CYiD3GGz8wim1iYhI7aNwI7VeXKt6tGgQQHaBjfkbD5TfsNSCmu+Arcg5BYqISK1SK8LN5MmTiYmJwdfXl969e7N27dpKvW/WrFmYTCaGDh1aswWKS5lMJsYUrxY+fdVeKpxUu+tI8K8PJ5Idt4aLiEid4/JwM3v2bB577DEmTJhAQkICXbp0YdCgQRw6VMGtv8DevXt54oknuPTSS51UqbjSX7o1JsBqYffhbFbuOlp+Q28/6H2P47kW1BQRqZNcHm7efPNN7rrrLsaNG0f79u354IMP8Pf3Z8qUKeW+x2azMXLkSF566SVatGhR4fHz8/PJyMgo9RD3E+TrzU3dmwAwPX5vxY173gne/pC62bEsg4iI1CkuDTcFBQVs2LCBgQMHlmwzm80MHDiQ+Pj4ct/3j3/8g4YNG3LHHXec8zMmTpxYau2r6OjoaqldnG908aWpZdvT2Hcsp/yG/uHQbbTj+cq3ar4wERGpVVwabo4cOYLNZiMiIqLU9oiICFJTU8t8z4oVK/j000/5+OPKzWXyzDPPkJ6eXvLYt2/fBdctrtGqYSCXtKqP3YAv1iRX3LjP/WCywO4fIWWzcwoUEZFaweWXpaoiMzOTUaNG8fHHH1O/fv1KvcfHx4fg4OBSD3Ffo2Mdq4XPWpdMXqGt/IZhzaDjXxzPV73thMpERKS2cGm4qV+/PhaLhbS0tFLb09LSiIyMPKv97t272bt3L0OGDMHLywsvLy9mzJjBggUL8PLyYvfu3c4qXVxkQLsIGof6cSKnkAW/Hay4cd/iJRm2fg3HK5gAUEREPIpLw43VaqV79+4sW7asZJvdbmfZsmXExsae1f6iiy5iy5YtbNq0qeRx/fXX079/fzZt2qTxNHWAxWzitj6O3ptz3hYe1Rla9AfDBqvfc1KFIiLiai6/LPXYY4/x8ccfM336dLZv3859991HdnY248aNA2D06NE888wzAPj6+tKxY8dSj9DQUIKCgujYsSNWq9WVpyJOckvPaHy8zPx+MIOE5BMVNz65JEPCDMg5VuO1iYiI67k83AwfPpx//etfvPDCC3Tt2pVNmzaxePHikkHGycnJpKSkuLhKqU3CAqxc36URADPOdVt4i34Q2RkKc2DdJzVem4iIuJ7JqLBf3/NkZGQQEhJCenq6Bhe7sa0H0rnunRV4W0ysfPoKGgb5lt94yzz46g7wrweP/u6Y6E9ERNxKVX5/u7znRuR8dGwcQremoRTaDGauOcft/e2HQmhTyDkKm7SgpoiIp1O4Ebc1pni18C/WJFFos5ff0OIFscULaq56F+wV3EIuIiJuT+FG3NbVHaOoH+jDocx8lvxe9qSPJS4eCX7hcDwRtv/XOQWKiIhLKNyI27J6mbm1d1MAZqw6xzw21gDodbfjuRbUFBHxaAo34tZG9m6Kl9nE2r3H2HbwHIui9roLvPzgYALsXeGcAkVExOkUbsStRQT7MqijYzbrc94WHlAfLr7N8VwLaoqIeCyFG3F7Y4sHFn+z6QAncgoqbhz7AJjMsGsppG6t+eJERMTpFG7E7fVoFka7qGDyCu3MXb+/4sbhzR23hgOseqfGaxMREedTuBG3ZzKZGFO8Wvhnq5Ow2c8xWDju5IKa8+DEOebIERERt6NwIx7hhq6NCfb1IvlYDj/vPFRx40YXQ/PLwF4Eq993ToEiIuI0CjfiEfysFob3dKwKPz3+HLeFw6kFNTdMg9zjNVeYiIg4ncKNeIxRfWIwmeCXPw6z53BWxY1bDoCIjlCYDes+dU6BIiLiFAo34jGa1vPnirYNAcfYmwqZTKd6b9Z8AIV5NVydiIg4i8KNeJTRxbeFz1u/n+z8ooobd7gRQqIh+zD8NrPmixMREadQuBGPcmmr+jSvH0BmfhFfbzxQcWOLt2PeG4B4LagpIuIpFG7Eo5jNJkb1cdwWPmPVXoxzrSF18SjwDYWju2DndzVfoIiI1DiFG/E4N/dogr/Vwp+Hsojfc7Tixj6BjjWnAH79DyT+AlvmQeKv6skREXFTCjficYJ9vflLt8ZAJVYLB+h1D5i94OAGmD4EvroDpl8HkzrCtgU1XK2IiFQ3hRvxSKNjYwD4flsqB07kVtw4Od4xod+ZMlJgzmgFHBERN6NwIx6pTUQQsS3qYTfgi4puC7fbYPFT5ewsHq+z+GldohIRcSMKN+KxxvR1DCyetW4feYXlhJOkVZBxsIKjGJBxwNFORETcgsKNeKyB7SJoFOLLsewCFm5OKbtRVlrlDlbZdiIi4nIKN+KxvCxmRp68LTx+b9mNAiMqd7DKthMREZdTuBGPdkvPaKwWM7/tT2djchkLZDbrC8GNAFP5B7H4QL3WNVajiIhUL4Ub8Wj1An24rksUADPKWi3cbIHBrxW/KCfg2PLhkytg//qaKVJERKqVwo14vDHFt4Uv3JzC4cz8sxu0vx6GzYDgqNLbgxs7gk/9No5BxVOvhg3TarxeERG5MCbjnPPTe5aMjAxCQkJIT08nODjY1eWIkwydvJJN+07wxFVtePCKci4x2W2Ou6Ky0hxjbJr1dfTs5GXAN/fBjv852nUbDVe/Ad6+zjsBEZE6riq/v9VzI3XCydvCP1+dTJHNXnYjswWaXwqdbnb8abY4tvsGw/DPYcAEMJkhYYajFyd9v5OqFxGRqlC4kTrhmk5R1AuwkpqRx/fbzuO2bpMJLn0MRs4DvzA4mAAfXu5Yi0pERGoVhRupE3y8LIzo1RSA6av2nv+BWg2Au5dDZGfIOQIzhsKqd6BuXd0VEanVFG6kzhjZpykWs4k1icfYkZpx/gcKawZ3fA9dRoBhg++fg3njID+r+ooVEZHzpnAjdUZUiB+DOjgm4yvztvCq8PaDoe/DNf9yrCj++3z4ZCAc3V0NlYqIyIVQuJE65eRq4fMTDpCeW3hhBzOZoNddMHYhBEbC4e3wUT/YueiC6xQRkfOncCN1Su/m4bSNCCK30Mbc9fuq56BN+8A9yyG6D+RnwMxb4KdXwF7OXVkiIlKjFG6kTjGZTIwuvi38s9VJ2O3VNBA4KBLG/Bd63eN4vfw1mDkccstY8kFERGqUwo3UOTde3JggXy+Sjuaw/M/D1XdgLytc8zrc+CF4+cKf3zsuU6Vurb7PEBGRc1K4kTrH3+rFsB7RAMy4kNvCy9PlFsfdVKFN4fhex0DjzXOr/3NERKRMCjdSJ43q47g09fMfh9l7JLv6PyCqi2M+nJYDoCgXvr4TFj8DtgscxCwiIuekcCN1Ukz9APq1bYBhOMbe1Aj/cBg5Fy59wvF69XuOSf+yDtXM54mICKBwI3XYydXC56zfR05BUc18iNkCA56H4V+ANQiSVjiWbdi3rmY+T0REFG6k7rq8TQOa1fMnM6+IbzYerNkPa3cd3P0T1G8LmQcdC2+un6JlG0REaoDCjdRZZrOpZOzNjPi9GDUdNOq3hruWQbvrwV4I/3sUFjwIhXk1+7kiInWMwo3UaX/tHo2ft4UdqZmsSTxW8x/oEwTDZsDAF8Fkho2fw9TBcKKaJhQUERGFG6nbQvy9GXpxYwCmr0okfvdRvt10gPjdR7FV1wR/ZzKZ4JJH4bavwS8cDm6Ejy6HPctr5vNEROoYk1HjffG1S0ZGBiEhIaSnpxMcHOzqcqQW2JGaweBJv561PSrElwlD2jO4Y1TNffiJZJh9G6T85ujJGfgS9B3vCEAiIlKiKr+/1XMjdV5589ykpudx3+cJLN6aUnMfHtoUbl8CXUeCYYelz8PcsZCfVXOfKSLi4RRupE6z2Q1e+u+2Mved7NJ86b/bau4SFYC3H9wwGa79N5i9Yds38MkAOLKr5j5TRMSDKdxInbY28Rgp6eXfrWQAKel5rK3pwcYmE/S8E8YuhMBIOLwDPu4PO76r2c8VEfFACjdSpx3KrNxt2JVtd8Ga9oZ7foGmfSE/A2aNgB//D+w253y+iIgHULiROq1hkG+l2h04noO9Ji9NnS4oAsYsgN73Ol7/8jp8ORxynHCruoiIB1C4kTqtV/NwokJ8Ode9Sa8v+YMBby5n2spEsvJraKmG01m84erX4MaPwMsPdi11XKZK3VLzny0i4uYUbqROs5hNTBjSHuCsgHPy9cB2DQny9SLxSDYv/ncbsa8s4+X/bSP5aE7NF9hlONzxPYQ2g+N74ZMrYfOcmv9cERE3pnluRIDFW1N46b/bSg0uPn2em+z8Ir5K2M+0lXvZU3zruMkEA9tFMC4uhtgW9TDV5Nw0Ocfg67tg1w+O173vg6tedvTwiIjUAVX5/a1wI1LMZjdYm3iMQ5l5NAzypVfzcCzm0oHFbjdY/udhpq7cyy9/HC7ZflFkEOPiYriha2N8vS01U6DdBj9PhF/ecLxu2hf+Os0xRkdExMMp3FRA4Uaqy65DmUxduZevEw6QW+i4myk8wMqtvZoyKrYZEcGVG6xcZTsWwvx7HXdTBUU51qqK7lUznyUiUkso3FRA4UaqW3pOIbPWJTMjPokDJ3IB8DKbuKZTFOPiYri4aVj1f+iRPx3LNhze4Zj47+rXoMftWrZBRDyWwk0FFG6kphTZ7CzdlsbUlXtZu/fUbdsXNw1lXFxzru4YibelGsfw52fCtw/Atm8dr7veBtf+yzHjsYiIh1G4qYDCjTjD1gPpTFmZyP9+S6HAZgcgMtiXUbHNGNGrKeEB1ur5IMOAVW/DDy861qaK6grDP3OsWSUi4kEUbiqgcCPOdDgzny/WJPH56mSOZOUD4ONlZmjXxoy7JIaLIqvp/8E9P8PccZB7DPzC4eYp0LJ/9RxbRKQWULipgMKNuEJ+kY2Fm1OYunIvWw6kl2zv27Ie4+Kac8VFDc+6M6vKTiTD7FGQsglMZhgwAeIe1jgcEfEICjcVULgRVzIMgw1Jx5myMpHFW1M5uaJD03B/xvSNYViPJgT5XsDcNYV5sPBx2PS543W762Hoe+ATdOHFi4i4kMJNBRRupLY4cCKXGfF7mbV2H+m5hQAEWC38tUc0Y/vGEFM/4PwObBiwYSp89yTYC6F+W7jlC6jfuhqrFxFxrqr8/q4Vyy9MnjyZmJgYfH196d27N2vXri237ccff8yll15KWFgYYWFhDBw4sML2IrVV41A/nrm6HfHPXMH/3diRVg0DyS6wMW3VXvr/+2fumLaOFX8eocr//jCZHLeFj1vkmAfnyE74qD9s/1/NnIiISC3j8nAze/ZsHnvsMSZMmEBCQgJdunRh0KBBHDp0qMz2P//8MyNGjOCnn34iPj6e6OhorrrqKg4cOODkykWqh7/Vi5G9m7H00cuYcXsv+rdtgGHAsh2HuO3TNQya9Atfrkkmt8BWtQNH94R7foFmcVCQCbNHwrKXHTMdi4h4MJdflurduzc9e/bk3XffBcButxMdHc348eN5+umnz/l+m81GWFgY7777LqNHjz5ne12WEnew53AW01ftZe6G/eQUh5pQf29G9GrK6NhmRIVUYS4bWyEsfQFWv+d43XIA3PQJ+IfXQOUiIjXDbS5LFRQUsGHDBgYOHFiyzWw2M3DgQOLj4yt1jJycHAoLCwkPL/sv6vz8fDIyMko9RGq7Fg0CeemGjsQ/M4Dnrm1HkzA/TuQU8v7Pu7nktZ944MsENiQdq9wlK4s3DJ4If/kEvPxg9zL4qB+kbK7x8xARcQWXhpsjR45gs9mIiCi98F9ERASpqamVOsZTTz1Fo0aNSgWk002cOJGQkJCSR3R09AXXLeIsIX7e3HlpC5b/rT8fjupOnxbh2OwGCzencNP78dwweSXzN+6noMh+7oN1/ivc+QOExcCJJPj0Svhtdo2fg4iIs7l8zM2FePXVV5k1axbz58/H17fsRQqfeeYZ0tPTSx779u1zcpUiF85iNjGoQySz7o7lu4cuZViPJli9zGzen86js38j7rUfeXvZnyUTBZYrsiPc/TO0uhKK8mD+3Y67qmyFTjkPERFncGm4qV+/PhaLhbS0tFLb09LSiIyMrPC9//rXv3j11Vf5/vvv6dy5c7ntfHx8CA4OLvUQcWftGwXz+s1diH/6Ch6/sg0Ng3w4nJnPm0v/oO+rP/LE3N/4/WB6+QfwC4Nb58DlTzler/0Qpg+BzLTy3yMi4kZcGm6sVivdu3dn2bJlJdvsdjvLli0jNja23Pe9/vrrvPzyyyxevJgePXo4o1SRWqdeoA/jB7RmxVNX8NYtXekSHUpBkZ15G/Zz7dsrGPZhPIu3pmKzlzEux2yG/s/CiFngEwzJ8fDhZZC8xvknIiJSzVx+t9Ts2bMZM2YMH374Ib169WLSpEnMmTOHHTt2EBERwejRo2ncuDETJ04E4LXXXuOFF17gyy+/JC4uruQ4gYGBBAYGnvPzdLeUeLKE5ONMXbmX77aklISaJmF+jImNYVjPaEL8ypj9+OhumDUSDm8Hc/Hg4553atkGEalV3G6G4nfffZc33niD1NRUunbtyttvv03v3r0B6NevHzExMUybNg2AmJgYkpKSzjrGhAkTePHFF8/5WQo3UhekpOfyWXwSM9cmczzHMZ7G32rhpm5NGBsXQ8sGZ/xDID8LFjwIv893vO5yK1z3JnhX4ZZzEZEa5HbhxpkUbqQuySu08c3GA0xduZedaZkl2/u1bcC4uOZc1ro+ppM9NIYB8e865sQx7BDZGYZ/DmHNXFS9iMgpCjcVULiRusgwDOJ3H2XKykSW7TjEyZ/6lg0CGBvXnJu6Ncbf6uXYuGc5zBsHOUfBLxxu/hRaXuG64kVEULipkMKN1HV7j2QzPX4vc9fvJyu/CIBgXy9uKZ79uEmYP5zYB3NGw8EEMJnhiufhkkc1DkdEXEbhpgIKNyIOmXmFzNuwn2mr9pJ0NAcAswkGdYhkXFxzejbxw/Td32DjZ443tBsCQ98HnyAXVi0idZXCTQUUbkRKs9kNftpxiKmrElm562jJ9g6NghkX15wbbN/jveQpsBVA/TYw/Ato0MaFFYtIXaRwUwGFG5Hy7UzNZNqqRL5OOEB+8ZIO9QOtPN4+k2F7nsWSlQLWILjxfUdPjoiIkyjcVEDhRuTcjmUXMHNtMp/FJ5GakQdApCWdz0M+pFXOJkejSx+H/n8Hs8V1hYpInaFwUwGFG5HKK7TZWbw1lakrE0lIPoEXRTzlNYu7vL4DwN7iCsw3fwr+4S6uVEQ8ncJNBRRuRM7Pb/tOMHVlIv/bnMLVrOQ174/xN+WT4dsI0/DPCGqupVBEpOYo3FRA4UbkwqRl5PH56iTWrv6V14peJ8acRp7hzX+bPknX6+6jdYTuphKR6qdwUwGFG5HqkVdoY9H6HTT68WF6F64DYHrRlfwU8whjLmnD5W0aYDZrXhwRqR4KNxVQuBGpXobdxoFvXqTJ5rcBWGdvw/0FDxNUvwlj+sZwU/cmBPp4ubhKEXF3CjcVULgRqSE7F2P/6i7MBRkcJpR78x9mg9GWIB8vhvWMZmzfGKLD/V1dpYi4KYWbCijciNSgo7th9m1waBt2kxfveN/OfzIuB0yYTTCwXQTj4prTp0X4qQU7RUQqQeGmAgo3IjWsIBsWjIetXwGQEnMjfy+8nR93n1qV/KLIIG6Pa871XRvh6615ckTk3BRuKqBwI+IEhgGr34PvnwfDBpGd2DvwQz7eYufrhAPkFtoACA+wcmuvpoyKbUZEsK+LixaR2kzhpgIKNyJOlPgLzB0HOUfALwxu+pT0Rpcxa10yM+KTOHAiFwAvs4lrO0cxLq45XaNDXVuziNRKCjcVULgRcbL0/TBnNBzYAJhgwPNwyWMU2Q2WbktjyspE1u09XtL84qahjItrztUdI/G2mF1Xt4jUKgo3FVC4EXGBonz47m+QMN3x+qLrYOj74Ov4Gdx6IJ0pKxP5328pFNgcC3ZGBvsyKrYZt/ZqSliA1VWVi0gtoXBTAYUbERfaMB2+ewJsBVCvNdzyBTRoW7L7cGY+X6xJ4vPVyRzJygfAx8vMjRc3Zlxcc9pGavZjkbpK4aYCCjciLrZ/A8wZBRkHwBro6MFpf32pJvlFNv73WwpTVyWy9UBGyfa+Letxe1xzrrio4VmzH9vsBmsTj3EoM4+GQb70ah6ORTMki3gMhZsKKNyI1AJZh2HeONj7q+P1JY/CFc+DufRt4YZhsD7pOFNXJrJ4ayr24r+tmtXzZ0xsDH/t0YQgX28Wb03hpf9uIyU9r+S9USG+TBjSnsEdo5x1ViJSgxRuKqBwI1JL2IrghwkQ/67jdYv+cNOnEFCvzOb7j+fwWXwSM9cmk5FXBECgjxc9Y8L4aefhs9qf7LN5/7ZuCjgiHkDhpgIKNyK1zNav4NsHoTAHQprC8M+gUddym+cUFPF1wgGmrdrLrkNZFR7aBESG+LLiqSt0iUrEzSncVEDhRqQWStsGs0fCsT3g5QvX/Qe63lrhWwzD4KNf9jBx0Y5zHn5MbDO6NQsjzN9KeICVsAAr4f5W/KyaHVnEXVTl97eW6hUR14toD3f9BPPvgT8Wwzf3OebFGTQRvMq+DdxkMhEZUrlZjafHJzE9Pums7b7eZsL9rYSWCj3ejj8DrKfCUPGfof7eWi5CxA0o3IhI7eAXCrfMhF/egJ8nwrpPIGUzDJsBwWWPmWkYVLlw06e5Y6HO4zkFHMsu4HhOAYU2g7xCOwfT8zh42kDkc/G3Ws7oAfIu6Qk6GYpC/b0JL94W6m/F6qXJCEWcSeFGRGoPsxn6PeUYc/P1XbB/LXx0Ofx1GjTre1bzXs3DiQrxJTU9j7Kur58cc/PFXX1KjbkxDIOs/CKOZxc6Ak9OAcezTwWfY9mFjtfF24/nONrZ7AY5BTZyCnJLlo6ojCAfL8LOCEOle4W8SwWmUD9vvDQ7s8h505gbEamdju6G2aPg0O9g9oJBr0Cvu8FUemDw4q0p3Pd5AkCpgFPdd0vZ7QaZ+UWlQs/pYehEzumvTwWi8/0bNsTP+1Qv0Gm9QmWFoTB/KyF+3u4/aNpug6RVkJUGgRGOQGvWZUBx0IDiCijciLiRgmxY8BBsned43Xk4XDcJrP6lmtXWeW5sdoOM3MJSYehETmEZ4cgRho5lF5CeW3hen2UyQajfGZfISkKRIwyFnRaSwv2tBPl6nTUZostsW4Cx+ClMGQdLNhnBjTANfu2sSR6lblK4qYDCjYibMQxY/T58/xwYNojo5LhdPLx5qWaeMkNxkc1Oem5hSY9QqQB0eq9RzqneoszieX+qymI2EebvfSr0+J/sCfIuPaC6ZJ83gT5emEzV/N912wKMOaMxMDj9YpwdMGHCNGyGAo4o3FRE4UbETe1dAXPHQvZh8A11TPjXeqCrq6oVCorsnMgt4HgZYejk5bEzt2cX2M7rs7wtplJ3j5V1V9npYSjM34q/1VJ+ILLbyH2jPT45qZSVRe0G5PtH4ve3bbpEVccp3FRA4UbEjaUfgDmj4cB6wARX/B0uedwxEFmqJK/Q5rhEVhx6jpdcKis7DB3LKSCv0F7hMU3Y8aEQP/LxowBfUwF+FBBoKaShr516Pnbq+RQR5m0j1LuIYK8iIvP30iZlwTnrtV/2JObo3uAT5FhN3ifY8ac18KxxWOKZFG4qoHAj4uaK8mHRU7BhquN122vhxvcdv+Q0GPVshuFYhb0wt/iRA0V5p54X5p22Lee0drlnbbMV5FCUl42tIBd7gWO7qSgXiy0Piy0Pb6PA6adnx0y+JYBCrwAKvQIp8g7CZg3C8CkOQD5BmP1CsPiFYPEPwRoQhjUgFKt/MCbfkFNBSf+v1HoKNxVQuBHxEAkzYOETYMuHwEgw7JB96NT+4EZQmwej2oqgKPeMMJF7Rugoa1vOGdsrsc2ouMelRlisGN5+GF6+2Cx+FJl9KTRbyTf5kGdYyTV8yDa8Kcw6Rq/Cdec83DZ7UwxMBJJLkCmHIHLxNp3fpbWy5OBHjtmfPHMA+ZYA8i2BJWGpyBqE3Rrk6DXyCcHkF4zZNwQv/xC8/UPxDgjBJzAMP18//KwW/K0WvOvorfw1OfZN4aYCCjciHuTABvj8r5B7tIydxX+hVmUwqmFUvlejVA/ImdtOCyflbbOf311RF8RkBm9/8PZzPLz8Tj339nPs8/ItZ5t/6e1lbjvteSV7QuL/PESzz3sTybFyx9ykUo/FA5YQ0zC4eJ4hG7n5RRTmZ2PLzcDIPYGRn4kpLwNzQSaWwky8CjPxLsrCWpSFry0bX3s2/vZsAsghiJySgORrqr7vIc/wJhN/Mgx/svAn1+xPrimAPEsAecVhqdA7EJt3IHZrMDaro2fJ5BeCyTcYL79gfHwD8fPxws/bEZIcYcmr5Lmft+NRa+5yO83irSm8vGAL0Vm/0ZATHCKUfYFdeP76TtVy16KWXxCRuiGqK1i8y9lZ/O+2+ffCjoWOHp7Cc/SUFFV+Yr5qdVbIOJ/gcVrYKHnvGdss3rVufEqvlg34u/edvFL4OnaDUgHHXvwVvu19B/93Satq6QEostnJLbSRW2AjtcBGbm4OBTnpFGafoDDnBPbcdEdgysvAnJ+BqcARmLwKHGHJuygbH1sWvrYs/OzZ+Bs5+OOYgsDXVIgv6TQwpZ/6QAMoKn7kn7u+QsNCJn5kGv5k4k+m4c8R/Mgotc2PPEsABZYgCr0CzuhdCsbsE4SfT3Eg8raU9Cb5Wb3wPy00OQKUV8n+k9utFnOV74hbvDWFb778gLneM2hkPVay/WB+OP/4cjTceq9Tp2VQuBER95W0CrJSK25TmA2bZ1X92BbrBYSMygSP03pAalngcCaL2US/obdz/5cFvOA9g0ac+sWYSj3+UTiKoX+9vdoubXhZzARZzAT5ngzFAUCDCzuorQgKMjHy0inMSSc/6zgF2Y7AZMvNwJ6XjpGbDnkZcFpY8irMcvQu2bLwsWVjxsDbZCOcLMJNFa94DziCU2HxI+e0cgwT2fiRURyEToakTPzIMvw4VPz69P1ZJ9vhT7bJH5t3ED5W75KAdCoQeZUKQv5WCz5eZvb8Oov3vCedVWIkx3jPexLPfmPlyvbPOm16BoUbEXFfWWmVa9fxZojufUbIOEfw0ABTpxncMQpuvZe/Log7+5LGX6vnkkaNsniBXxgmvzCsYVD2Uq/nYLdDQRbkZ0B+piMI5WdAXnrxn47epKLcdGy56Ri5GRjF+8wFmY7AVJiF2SjCYjIIJodgck5N1X0esgp8ySrwKwlGJ3uOMgw/sk4LRmmGLy94f4mJs3O62eTogXuo8FPW7r6L2NYNz7+gKlC4ERH3FRhRuXbdx0LzS2u0FLkwgztGcWX7SNYmdnf7iRjPi9nsuHPLt/yxJCbAu/hRJsNwXGYtDkOnwlHmGduK/zxjm1H8p8nmuH4WaMojkDwiTccv7NRM0Iij7Nm7ElrfeEHHqiyFGxFxX836Ou6KykiB8pbODG5U5qKbUvtYzCZiW9ZzdRnuy2RyLE1i9YegyKq//eSTovzi3qP0MkJR5lk9StkHtxNwYuc5j9/QdKLKNZ0vhRsRcV9mi+N27zmjcfzVXMbSmYNf1SUmkarw8nE8AupXqrnvnl9gxpBztmvZouWFVlZpdfNGfBHxHO2vd9zuHXzGuIzgRlW7DVxEzoslJo5cv8iSu9vOZDcg1y8SS0yc02pSz42IuL/218NF12qGYhFXMFvwG/IGxpzR2Mta/NRkwm/IG079eVS4ERHPYLZo0LCIq7S/3rF6++KnIONgyWZTcGNMg191eg+qwo2IiIhcuPbXYzqjB9Xkoh5UhRsRERGpHrWkB1UDikVERMSjKNyIiIiIR1G4EREREY+icCMiIiIeReFGREREPIrCjYiIiHgUhRsRERHxKAo3IiIi4lEUbkRERMSj1LkZig3DsWxpRkaGiysRERGRyjr5e/vk7/GK1Llwk5mZCUB0dLSLKxEREZGqyszMJCQkpMI2JqMyEciD2O12Dh48SFBQECaTqVqPnZGRQXR0NPv27SM4OLhaj10bePr5geefo87P/Xn6Oer83F9NnaNhGGRmZtKoUSPM5opH1dS5nhuz2UyTJk1q9DOCg4M99n9a8PzzA88/R52f+/P0c9T5ub+aOMdz9dicpAHFIiIi4lEUbkRERMSjKNxUIx8fHyZMmICPj4+rS6kRnn5+4PnnqPNzf55+jjo/91cbzrHODSgWERERz6aeGxEREfEoCjciIiLiURRuRERExKMo3IiIiIhHUbiposmTJxMTE4Ovry+9e/dm7dq1FbafO3cuF110Eb6+vnTq1InvvvvOSZWen6qc37Rp0zCZTKUevr6+Tqy2an755ReGDBlCo0aNMJlMfPPNN+d8z88//0y3bt3w8fGhVatWTJs2rcbrPF9VPb+ff/75rO/PZDKRmprqnIKraOLEifTs2ZOgoCAaNmzI0KFD2blz5znf504/g+dzju70c/j+++/TuXPnksndYmNjWbRoUYXvcafvr6rn507fXVleffVVTCYTjzzySIXtXPEdKtxUwezZs3nssceYMGECCQkJdOnShUGDBnHo0KEy269atYoRI0Zwxx13sHHjRoYOHcrQoUPZunWrkyuvnKqeHzhmoExJSSl5JCUlObHiqsnOzqZLly5Mnjy5Uu0TExO59tpr6d+/P5s2beKRRx7hzjvvZMmSJTVc6fmp6vmdtHPnzlLfYcOGDWuowguzfPlyHnjgAVavXs3SpUspLCzkqquuIjs7u9z3uNvP4PmcI7jPz2GTJk149dVX2bBhA+vXr+eKK67ghhtu4Pfffy+zvbt9f1U9P3Cf7+5M69at48MPP6Rz584VtnPZd2hIpfXq1ct44IEHSl7bbDajUaNGxsSJE8tsP2zYMOPaa68tta13797GPffcU6N1nq+qnt/UqVONkJAQJ1VXvQBj/vz5FbZ58sknjQ4dOpTaNnz4cGPQoEE1WFn1qMz5/fTTTwZgHD9+3Ck1VbdDhw4ZgLF8+fJy27jbz+CZKnOO7vxzaBiGERYWZnzyySdl7nP3788wKj4/d/3uMjMzjdatWxtLly41Lr/8cuPhhx8ut62rvkP13FRSQUEBGzZsYODAgSXbzGYzAwcOJD4+vsz3xMfHl2oPMGjQoHLbu9L5nB9AVlYWzZo1Izo6+pz/QnE37vT9XYiuXbsSFRXFlVdeycqVK11dTqWlp6cDEB4eXm4bd/8OK3OO4J4/hzabjVmzZpGdnU1sbGyZbdz5+6vM+YF7fncPPPAA11577VnfTVlc9R0q3FTSkSNHsNlsRERElNoeERFR7hiF1NTUKrV3pfM5v7Zt2zJlyhS+/fZbPv/8c+x2O3379mX//v3OKLnGlff9ZWRkkJub66Kqqk9UVBQffPABX331FV999RXR0dH069ePhIQEV5d2Tna7nUceeYS4uDg6duxYbjt3+hk8U2XP0d1+Drds2UJgYCA+Pj7ce++9zJ8/n/bt25fZ1h2/v6qcn7t9dwCzZs0iISGBiRMnVqq9q77DOrcquFSf2NjYUv8i6du3L+3atePDDz/k5ZdfdmFlUhlt27albdu2Ja/79u3L7t27+c9//sNnn33mwsrO7YEHHmDr1q2sWLHC1aXUmMqeo7v9HLZt25ZNmzaRnp7OvHnzGDNmDMuXLy83ALibqpyfu313+/bt4+GHH2bp0qW1fuCzwk0l1a9fH4vFQlpaWqntaWlpREZGlvmeyMjIKrV3pfM5vzN5e3tz8cUXs2vXrpoo0enK+/6Cg4Px8/NzUVU1q1evXrU+MDz44IP873//45dffqFJkyYVtnWnn8HTVeUcz1Tbfw6tViutWrUCoHv37qxbt4633nqLDz/88Ky27vj9VeX8zlTbv7sNGzZw6NAhunXrVrLNZrPxyy+/8O6775Kfn4/FYin1Hld9h7osVUlWq5Xu3buzbNmykm12u51ly5aVez01Nja2VHuApUuXVnj91VXO5/zOZLPZ2LJlC1FRUTVVplO50/dXXTZt2lRrvz/DMHjwwQeZP38+P/74I82bNz/ne9ztOzyfczyTu/0c2u128vPzy9znbt9fWSo6vzPV9u9uwIABbNmyhU2bNpU8evTowciRI9m0adNZwQZc+B3W6HBlDzNr1izDx8fHmDZtmrFt2zbj7rvvNkJDQ43U1FTDMAxj1KhRxtNPP13SfuXKlYaXl5fxr3/9y9i+fbsxYcIEw9vb29iyZYurTqFCVT2/l156yViyZImxe/duY8OGDcYtt9xi+Pr6Gr///rurTqFCmZmZxsaNG42NGzcagPHmm28aGzduNJKSkgzDMIynn37aGDVqVEn7PXv2GP7+/sbf/vY3Y/v27cbkyZMNi8ViLF682FWnUKGqnt9//vMf45tvvjH+/PNPY8uWLcbDDz9smM1m44cffnDVKVTovvvuM0JCQoyff/7ZSElJKXnk5OSUtHH3n8HzOUd3+jl8+umnjeXLlxuJiYnG5s2bjaefftowmUzG999/bxiG+39/VT0/d/ruynPm3VK15TtUuKmid955x2jatKlhtVqNXr16GatXry7Zd/nllxtjxowp1X7OnDlGmzZtDKvVanTo0MFYuHChkyuumqqc3yOPPFLSNiIiwrjmmmuMhIQEF1RdOSdvfT7zcfKcxowZY1x++eVnvadr166G1Wo1WrRoYUydOtXpdVdWVc/vtddeM1q2bGn4+voa4eHhRr9+/Ywff/zRNcVXQlnnBpT6Ttz9Z/B8ztGdfg5vv/12o1mzZobVajUaNGhgDBgwoOQXv2G4//dX1fNzp++uPGeGm9ryHZoMwzBqtm9IRERExHk05kZEREQ8isKNiIiIeBSFGxEREfEoCjciIiLiURRuRERExKMo3IiIiIhHUbgRERERj6JwIyIiIh5F4UZE6jyTycQ333zj6jJEpJoo3IiIS40dOxaTyXTWY/Dgwa4uTUTclJerCxARGTx4MFOnTi21zcfHx0XViIi7U8+NiLicj48PkZGRpR5hYWGA45LR+++/z9VXX42fnx8tWrRg3rx5pd6/ZcsWrrjiCvz8/KhXrx533303WVlZpdpMmTKFDh064OPjQ1RUFA8++GCp/UeOHOHGG2/E39+f1q1bs2DBgpo9aRGpMQo3IlLrPf/889x000389ttvjBw5kltuuYXt27cDkJ2dzaBBgwgLC2PdunXMnTuXH374oVR4ef/993nggQe4++672bJlCwsWLKBVq1alPuOll15i2LBhbN68mWuuuYaRI0dy7Ngxp56niFSTGl93XESkAmPGjDEsFosREBBQ6vF///d/hmEYBmDce++9pd7Tu3dv47777jMMwzA++ugjIywszMjKyirZv3DhQsNsNhupqamGYRhGo0aNjL///e/l1gAYzz33XMnrrKwsAzAWLVpUbecpIs6jMTci4nL9+/fn/fffL7UtPDy85HlsbGypfbGxsWzatAmA7du306VLFwICAkr2x8XFYbfb2blzJyaTiYMHDzJgwIAKa+jcuXPJ84CAAIKDgzl06ND5npKIuJDCjYi4XEBAwFmXiaqLn59fpdp5e3uXem0ymbDb7TVRkojUMI25EZFab/Xq1We9bteuHQDt2rXjt99+Izs7u2T/ypUrMZvNtG3blqCgIGJiYli2bJlTaxYR11HPjYi4XH5+PqmpqaW2eXl5Ub9+fQDmzp1Ljx49uOSSS/jiiy9Yu3Ytn376KQAjR45kwoQJjBkzhhdffJHDhw8zfvx4Ro0aRUREBAAvvvgi9957Lw0bNuTqq68mMzOTlStXMn78eOeeqIg4hcKNiLjc4sWLiYqKKrWtbdu27NixA3DcyTRr1izuv/9+oqKimDlzJu3btwfA39+fJUuW8PDDD9OzZ0/8/f256aabePPNN0uONWbMGPLy8vjPf/7DE088Qf369bn55pudd4Ii4lQmwzAMVxchIlIek8nE/PnzGTp0qKtLERE3oTE3IiIi4lEUbkRERMSjaMyNiNRqunIuIlWlnhsRERHxKAo3IiIi4lEUbkRERMSjKNyIiIiIR1G4EREREY+icCMiIiIeReFGREREPIrCjYiIiHiU/weMj3hRHv3ViwAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch [6 / 10], Step [22 / 225], Loss: 0.059457464990290726, Validation Loss: 0.01410769484937191\n", + "Epoch [6 / 10], Step [44 / 225], Loss: 0.06400176146152345, Validation Loss: 0.01610004436224699\n", + "Epoch [6 / 10], Step [66 / 225], Loss: 0.06258460139912186, Validation Loss: 0.01073336290816466\n", + "Epoch [6 / 10], Step [88 / 225], Loss: 0.059185962616042656, Validation Loss: 0.008050022181123495\n", + "Epoch [6 / 10], Step [110 / 225], Loss: 0.05729963897981427, Validation Loss: 0.006440017744898796\n", + "Epoch [6 / 10], Step [132 / 225], Loss: 0.055887209505520084, Validation Loss: 0.00799964057902495\n", + "Epoch [6 / 10], Step [154 / 225], Loss: 0.05486652876746345, Validation Loss: 0.006856834782021386\n", + "Epoch [6 / 10], Step [176 / 225], Loss: 0.054090704366734084, Validation Loss: 0.005999730434268713\n", + "Epoch [6 / 10], Step [198 / 225], Loss: 0.05347813244419868, Validation Loss: 0.005333093719349967\n", + "Epoch [6 / 10], Step [220 / 225], Loss: 0.05342629473995079, Validation Loss: 0.004799784347414971\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0mlosses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0mval_losses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mimg1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloaders\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'train'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 16\u001b[0m \u001b[0msize\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimg1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0mimg1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimg1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandperm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandperm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg3\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandperm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 631\u001b[0m \u001b[0;31m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 632\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# type: ignore[call-arg]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 633\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 634\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_num_yielded\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 635\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_kind\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0m_DatasetKind\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mIterable\u001b[0m \u001b[0;32mand\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m_next_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 675\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_next_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 677\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_dataset_fetcher\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 678\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pin_memory\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 679\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_pin_memory_device\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36mfetch\u001b[0;34m(self, possibly_batched_index)\u001b[0m\n\u001b[1;32m 49\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__getitems__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 52\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 49\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__getitems__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 52\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 53\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0mneg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mneg_indices\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[0mimg1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0manc\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 42\u001b[0;31m \u001b[0mimg2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAD\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpos\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 43\u001b[0m \u001b[0mimg3\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNC\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mneg\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 44\u001b[0m \u001b[0mlabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mY\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0manc\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mimage\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torchvision/transforms/transforms.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, img)\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransforms\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 95\u001b[0;31m \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 96\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 97\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1499\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1500\u001b[0m or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1502\u001b[0m \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1503\u001b[0m \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torchvision/transforms/transforms.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, img)\u001b[0m\n\u001b[1;32m 1534\u001b[0m \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_params\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdegrees\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtranslate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshear\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1535\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1536\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maffine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mret\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterpolation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minterpolation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfill\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfill\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcenter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcenter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1537\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1538\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__repr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torchvision/transforms/functional.py\u001b[0m in \u001b[0;36maffine\u001b[0;34m(img, angle, translate, scale, shear, interpolation, fill, center)\u001b[0m\n\u001b[1;32m 1244\u001b[0m \u001b[0mtranslate_f\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1.0\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtranslate\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1245\u001b[0m \u001b[0mmatrix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_get_inverse_affine_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcenter_f\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mangle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtranslate_f\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshear\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1246\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mF_t\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maffine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterpolation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minterpolation\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfill\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfill\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1247\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1248\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torchvision/transforms/_functional_tensor.py\u001b[0m in \u001b[0;36maffine\u001b[0;34m(img, matrix, interpolation, fill)\u001b[0m\n\u001b[1;32m 616\u001b[0m \u001b[0;31m# grid will be generated on the same device as theta and img\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 617\u001b[0m \u001b[0mgrid\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_gen_affine_grid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtheta\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mh\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mow\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moh\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 618\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_apply_grid_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrid\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterpolation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfill\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfill\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 619\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 620\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "from itertools import cycle\n", + "\n", + "test_iter = cycle(iter(loaders['test']))\n", + "# Training loop\n", + "epochs = 10\n", + "trip_model.to(device)\n", + "losses = []\n", + "val_losses = []\n", + "\n", + "transform_train = transforms.RandomAffine(degrees=5, translate=(0.05, 0.05), scale=(0.95, 1.05))\n", + "\n", + "for epoch in range(epochs):\n", + " losses.append([])\n", + " val_losses.append([])\n", + " for i, (img1, img2, img3, _) in enumerate(loaders['train']):\n", + " size = img1.size(0)\n", + " img1, img2, img3 = img1[torch.randperm(size)], img2[torch.randperm(size)], img3[torch.randperm(size)]\n", + " img1 = transform_train(img1)\n", + " img2 = transform_train(img2)\n", + " img3 = transform_train(img3)\n", + " img1, img2, img3 = img1.to(device), img2.to(device), img3.to(device)\n", + "\n", + "\n", + " out1, out2, out3 = trip_model(img1, img2, img3)\n", + "\n", + " loss = trip_criterion(out1, out2, out3)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " losses[epoch].append(loss.item())\n", + " if (i + 1) % (total_step // 10) == 0:\n", + "\n", + " with torch.no_grad():\n", + " val_img1, val_img2, val_img3, _ = next(test_iter)\n", + " val_img1, val_img2, val_img3 = val_img1.to(device), val_img2.to(device), val_img3.to(device)\n", + " val_out1, val_out2, val_out3 = trip_model(val_img1, val_img2, val_img3)\n", + " val_loss = val_criterion(val_out1, val_out2, val_out3)\n", + " val_losses[epoch].append(val_loss.item())\n", + "\n", + " print(f\"Epoch [{epoch + 1} / {epochs}], Step [{i + 1} / {total_step}], Loss: {np.mean(losses[epoch])}, Validation Loss: {np.mean(val_losses[epoch])}\")\n", + "\n", + " scheduler.step()\n", + " # Calculate mean of each row\n", + " mean_list1 = np.mean(losses, axis=1)\n", + " mean_list2 = np.mean(val_losses, axis=1)\n", + "\n", + " # Plot the means\n", + " plt.plot(mean_list1, label='Train Loss', marker='o')\n", + " plt.plot(mean_list2, label='Val Loss', marker='o')\n", + "\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Mean Loss')\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": { + "id": "nnGoOwX-Vk_i" + }, + "outputs": [], + "source": [ + "# # data = {}\n", + "# # labels = {}\n", + "# trip_model.eval()\n", + "# with torch.no_grad():\n", + "# embeddings = trip_model.forward_once\n", + "# for stage in ['train', 'cal', 'test']:\n", + "# data[stage] = []\n", + "# labels[stage] = []\n", + "# for i, (img1, _, _, label) in enumerate(loaders[stage]):\n", + "# img1 = img1.to(device)\n", + "# output = embeddings(img1)\n", + "# data[stage].extend(output.cpu().tolist())\n", + "# labels[stage].extend(label.tolist())" + ] + }, + { + "cell_type": "code", + "source": [ + "class Classifier(nn.Module):\n", + " def __init__(self, input_size, embedding, hidden_size, output_size):\n", + " super(Classifier, self).__init__()\n", + " self.embedding = embedding\n", + " self.fc1 = nn.Linear(input_size, hidden_size)\n", + " self.fc2 = nn.Linear(hidden_size, output_size)\n", + "\n", + " def forward(self, x):\n", + " with torch.no_grad():\n", + " detached_emb = self.embedding(x).detach()\n", + " print(detached_emb.shape)\n", + " x = torch.relu(detached_emb) # Taking the mean of embeddings across the embedding dimension\n", + " x = torch.relu(self.fc1(x))\n", + " x = self.fc2(x)\n", + " return x\n", + "# Assuming you have the appropriate input dimensions\n", + "input_size = 100 # Assuming 100 input features\n", + "embedded_size = 32 # Assuming an embedded size of 50\n", + "hidden_size = 100 # Size of the hidden layer\n", + "output_size = 2 # Size of the output layer\n", + "\n", + "# Creating an instance of the CustomNet\n" + ], + "metadata": { + "id": "LVYZvjpp8q7W" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "trip_model.eval()\n", + "learning_rate = 0.1\n", + "clas_model = Classifier(32, trip_model.forward_once, 100, 2)\n", + "clas_criterion = nn.BCELoss()\n", + "total_step = len(loaders['train'])\n", + "\n", + "clas_optimizer = optim.Adam(clas_model.parameters(), lr=learning_rate)" + ], + "metadata": { + "id": "hKKu2Pnx8_9M" + }, + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from itertools import cycle\n", + "\n", + "test_iter = cycle(iter(loaders['test']))\n", + "# Training loop\n", + "epochs = 10\n", + "clas_model.to(device)\n", + "clas_losses = []\n", + "clas_val_losses = []\n", + "\n", + "for epoch in range(epochs):\n", + " clas_losses.append([])\n", + " clas_val_losses.append([])\n", + " for i, (img, _, _, label) in enumerate(loaders['train']):\n", + " img, label = img.to(device), label.to(device)\n", + "\n", + "\n", + " output = clas_model(img)\n", + " loss = clas_criterion(output, label)\n", + " clas_optimizer.zero_grad()\n", + " loss.backward()\n", + " clas_optimizer.step()\n", + " clas_losses[epoch].append(loss.item())\n", + " if (i + 1) % (total_step // 10) == 0:\n", + "\n", + " with torch.no_grad():\n", + " val_img, _, _, val_label = next(test_iter)\n", + " val_img, val_label = val_img.to(device), val_label.to(device)\n", + " val_output = clas_model(val_img)\n", + " val_loss = val_criterion(val_output, val_label)\n", + " clas_val_losses[epoch].append(val_loss.item())\n", + "\n", + " print(f\"Epoch [{epoch + 1} / {epochs}], Step [{i + 1} / {total_step}], Loss: {np.mean(clas_losses[epoch])}, Validation Loss: {np.mean(clas_val_losses[epoch])}\")\n", + "\n", + " scheduler.step()\n", + " # Calculate mean of each row\n", + " mean_list1 = np.mean(clas_losses, axis=1)\n", + " mean_list2 = np.mean(clas_val_losses, axis=1)\n", + "\n", + " # Plot the means\n", + " plt.plot(mean_list1, label='Train Loss', marker='o')\n", + " plt.plot(mean_list2, label='Val Loss', marker='o')\n", + "\n", + " plt.xlabel('Epoch')\n", + " plt.ylabel('Mean Loss')\n", + " plt.legend()\n", + " plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "id": "NN17b-Wm9jHg", + "outputId": "e1009cd6-e393-49d7-c07f-f2ae2cd22aea" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "error", + "ename": "RuntimeError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mclas_val_losses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloaders\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'train'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m \u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRuntimeError\u001b[0m: CUDA error: device-side assert triggered\nCUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.\nFor debugging consider passing CUDA_LAUNCH_BLOCKING=1.\nCompile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "%env CUDA_LAUNCH_BLOCKING=1\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tVHkbGCDGVmR", + "outputId": "c8644104-3472-4653-a62c-fb7c4038010c" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "env: CUDA_LAUNCH_BLOCKING=1\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "id": "ayGTRCP5Wl0s", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "16c820eb-6070-4749-9e47-408606cee484" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Train Accuracy: 0.6839684014869889\n", + "Cal Accuracy: 0.8131111111111111\n", + "Val Accuracy: 0.7526666666666667\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.neural_network import MLPClassifier\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "# Split the data into training and testing sets\n", + "# X_train, X_test, y_train, y_test = train_test_split(embeddings, labels, test_size=0.2, random_state=42)\n", + "\n", + "# Train a logistic regression model\n", + "# classifier = LogisticRegression(max_iter=1000)\n", + "classifier = MLPClassifier(hidden_layer_sizes=(50, 20), max_iter=1000)\n", + "classifier.fit(data['cal'], labels['cal'])\n", + "\n", + "# Make predictions\n", + "train_predictions = classifier.predict(data['train'])\n", + "cal_predictions = classifier.predict(data['cal'])\n", + "val_predictions = classifier.predict(data['test'])\n", + "\n", + "# Calculate accuracy\n", + "train_accuracy = accuracy_score(labels['train'], train_predictions)\n", + "cal_accuracy = accuracy_score(labels['cal'], cal_predictions)\n", + "val_accuracy = accuracy_score(labels['test'], val_predictions)\n", + "print(f\"Train Accuracy: {train_accuracy}\")\n", + "print(f\"Cal Accuracy: {cal_accuracy}\")\n", + "print(f\"Val Accuracy: {val_accuracy}\")\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "machine_shape": "hm", + "provenance": [], + "gpuType": "A100", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/PCA.png b/PCA.png new file mode 100644 index 000000000..91ac8f052 Binary files /dev/null and b/PCA.png differ diff --git a/README.md b/README.md index 4a064f841..8d3772272 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,55 @@ -# Pattern Analysis -Pattern Analysis of various datasets by COMP3710 students at the University of Queensland. +# Description + +This contains methods to create embeddings via a Triplet Siamese Network, which can then be used to create a classifier for Alzheimer's disease using the ADNI dataset. The model attempts to identify Alzheimer's from MRIs, which would be very helpful for radiology. + +# Algorithm + +The triplet Siamese model works by taking in both a positive and negative input, as well as an anchor. An identical backbone (in this case, resnet) is used on all three inputs to produce an embedded space. The aim of the model is to make the distance between the positive and anchor less than the distance between the negative and the anchor, without knowing which camp the anchor belongs to. The lost function used to achieve this subtracts the negative distance from the positive to ensure a lower loss when closer to positive. This creates a good embedded space to then use to classify inputs. Using this, individual outputs from the embedded space can be inputted into a Random Forest Classifier, which can then be used to identify Alzheimers. + +# Pre-Processing + +Training Images are randomly rotated between -5 and 5 degrees, offset between -5% and 5% and scaled between 95% and 105%. They are then intensity normalized. After that, the mean and standard deviation is found for the entire training set, and both the training and testing sets are normalized using that mean and standard deviation. Finally, the training set is split into two, with 80% being used for the Triplet Siamese Model and the remaining 20% for the classifier. + +# Triplet Siamese Model + +Each epoch, each batch is randomly sorted to have a different triplet each time. The inputs then undergo the rotation, offset and scaling transform from pre-processing to keep the model on it's toes. The loss function is calculated using a tiny amount of L2 regularization, 0.0001. This helps with the generalization of the model. + +The learning rate begins very low at 0.0001, gradually increases to a normal level of low, 0.001, which is reached halfway through training. After the peak is reached, the learning rate decreased at the same rate back to its starting level. + +The optimizer used is a Scholastic Gradient Descent optimizer. When looking into the optimizer I discovered that weight decay and L2 regularization are the same thing, so actually 0.0005 is also used. + +# Classification Model + +The embedded space used for the three inputs in the Triplet Siamese Model is then used inside another model to classify individual inputs. The classification model is a Random Forest model, with 600 estimators, 250 min split and max depth of 12. This allows for more generalization and beats Neural Networks by quite a margin. + +# Dependencies + +Python version: 3.10.12 + +Pytorch version: 2.1.0, Cuda 11.8 + +Numpy version: 1.23.5 + +Matplotlib version: 3.7.1 + +Sklearn version: 1.2.2 + +PIL version: 9.4.0 + +# Inputs and Outputs + +![image](https://raw.githubusercontent.com/FinnRobertson15/PatternAnalysis-2023/topic-recognition/inputs.png) + +Top: 1 (Alzheimer's) + +Bottom: 0 (No Alzheimer's) + +# Results + +![image](https://raw.githubusercontent.com/FinnRobertson15/PatternAnalysis-2023/topic-recognition/PCA.png) + +Triplet loss graph + +![image](https://raw.githubusercontent.com/FinnRobertson15/PatternAnalysis-2023/topic-recognition/train.png) -We create pattern recognition and image processing library for Tensorflow (TF), PyTorch or JAX. - -This library is created and maintained by The University of Queensland [COMP3710](https://my.uq.edu.au/programs-courses/course.html?course_code=comp3710) students. - -The library includes the following implemented in Tensorflow: -* fractals -* recognition problems - -In the recognition folder, you will find many recognition problems solved including: -* OASIS brain segmentation -* Classification -etc. +Classification Accuracy of 65% \ No newline at end of file diff --git a/dataset.py b/dataset.py new file mode 100644 index 000000000..528409213 --- /dev/null +++ b/dataset.py @@ -0,0 +1,120 @@ +import torch + +import torchvision.transforms as transforms + +import os +from PIL import Image +from torch.utils.data import Dataset, DataLoader +import torch + +class CustomDataset(Dataset): + def __init__(self, root_dir, transform=None): + self.root_dir = root_dir + self.transform = transform + self.image_paths = os.listdir(root_dir) + + def __len__(self): + return len(self.image_paths) + + def __getitem__(self, idx): + img_name = os.path.join(self.root_dir, self.image_paths[idx]) + image = Image.open(img_name) + + if self.transform: + image = self.transform(image) + + return image + +class TripletDataset(Dataset): + def __init__(self, AD, NC, transform=None): + self.X = AD + NC + self.AD = AD + self.NC = NC + self.Y = torch.cat((torch.ones(len(AD)), torch.zeros(len(NC))), dim=0) + self.anc_indices = torch.randperm(len(self.X)) + self.pos_indices = torch.randperm(len(self.X)) % len(AD) + self.neg_indices = torch.randperm(len(self.X)) % len(NC) + self.transform = transform + + def __len__(self): + return len(self.anc_indices) + + def __getitem__(self, idx): + anc = self.anc_indices[idx] + pos = self.pos_indices[idx] + neg = self.neg_indices[idx] + img1 = self.X[anc] + img2 = self.AD[pos] + img3 = self.NC[neg] + label = self.Y[anc] + + if self.transform: + img1 = self.transform(img1) + img2 = self.transform(img2) + img3 = self.transform(img3) + + return img1, img2, img3, torch.tensor([1 - label, label]) + + + + +def intensity_normalization(img, mean = None, std = None): + mean = torch.mean(img) + std = torch.std(img) + return (img - mean) / std + +class CustomNormalize(object): + def __init__(self, mean, std): + self.mean = mean + self.std = std + + def __call__(self, img): + return (img - self.mean) / self.std + +transform_train = transforms.Compose([ + transforms.Resize((256, 256)), + transforms.ToTensor(), + transforms.RandomAffine(degrees=5, translate=(0.05, 0.05), scale=(0.95, 1.05)), # Random affine transformations with smaller parameters + transforms.Lambda(intensity_normalization) +]) + +transform_test = transforms.Compose([ + transforms.Resize((256, 256)), + transforms.ToTensor(), + transforms.Lambda(intensity_normalization) +]) + +class Normalize(object): + def __init__(self, mean, std): + self.mean = mean + self.std = std + + def __call__(self, img): + return (img - self.mean) / self.std + + + +def gen_loaders(root_dir = '', batch_size = 96): + loaders = {} + AD_train = CustomDataset(root_dir=root_dir + os.path.join('train', 'AD'), transform=transform_train) + NC_train = CustomDataset(root_dir=root_dir + os.path.join('train', 'NC'), transform=transform_train) + + X = torch.stack([img for img in AD_train + NC_train]) + mean = X.mean() + std = X.std() + normalize = transforms.Compose([ + Normalize(mean, std) + ]) + train_dataset = TripletDataset(AD_train, NC_train, normalize) + + + # Create DataLoaders for the two parts + loaders['train'] = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) + + AD_test = CustomDataset(root_dir=os.path.join('test', 'AD'), transform=transform_test) + NC_test = CustomDataset(root_dir=os.path.join('test', 'NC'), transform=transform_test) + + test_dataset = TripletDataset(AD_test, NC_test, normalize) + + loaders['test'] = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) + return loaders \ No newline at end of file diff --git a/inputs.png b/inputs.png new file mode 100644 index 000000000..6c1020bf3 Binary files /dev/null and b/inputs.png differ diff --git a/modules.py b/modules.py new file mode 100644 index 000000000..ab28c061c --- /dev/null +++ b/modules.py @@ -0,0 +1,60 @@ + +import torch +import torch.nn as nn +import torchvision.models as models +import torch.nn.functional as F + +class TripletSiameseNetwork(nn.Module): + def __init__(self, pretrained=True): + super(TripletSiameseNetwork, self).__init__() + self.resnet = models.resnet18(pretrained=pretrained) + self.resnet.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) + self.bn = nn.BatchNorm1d(1000) + self.fc1 = nn.Linear(1000, 128) + + def forward_once(self, x): + output = self.resnet(x) + output = self.bn(output) + output = self.fc1(output) + return output + + def forward(self, anchor, positive, negative): + output_anchor = self.forward_once(anchor) + output_positive = self.forward_once(positive) + output_negative = self.forward_once(negative) + return output_anchor, output_positive, output_negative + +class TripletLoss(nn.Module): + def __init__(self, margin=1.0): + super(TripletLoss, self).__init__() + self.margin = margin + + def forward(self, anchor, positive, negative): + distance_positive = F.pairwise_distance(anchor, positive) + distance_negative = F.pairwise_distance(anchor, negative) + losses = F.relu(distance_positive - distance_negative + self.margin) + return losses.mean() + +class TripletLossWithRegularization(nn.Module): + def __init__(self, model, margin=1.0, lambda_reg=0.0001): + super(TripletLossWithRegularization, self).__init__() + self.model = model + self.margin = margin + self.lambda_reg = lambda_reg # Regularization parameter + + def forward(self, anchor, positive, negative): + distance_positive = F.pairwise_distance(anchor, positive) + distance_negative = F.pairwise_distance(anchor, negative) + triplet_losses = F.relu(distance_positive - distance_negative + self.margin) + triplet_loss = triplet_losses.mean() + + # Compute L2 regularization + l2_reg = None + for param in self.model.parameters(): + if l2_reg is None: + l2_reg = param.norm(2) + else: + l2_reg = l2_reg + param.norm(2) + + loss = triplet_loss + self.lambda_reg * l2_reg + return loss diff --git a/predict.py b/predict.py new file mode 100644 index 000000000..936cb25da --- /dev/null +++ b/predict.py @@ -0,0 +1,26 @@ +from modules import TripletSiameseNetwork +from dataset import gen_loaders +import torch +import pickle + +def predict(input=gen_loaders()['test'], triplet_path = 'trip_model.pth', classifier_path='classifier.pickle'): + device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + trip_model = TripletSiameseNetwork() + trip_model = torch.load(triplet_path) + with open(classifier_path, 'rb') as f: + clf = pickle.load(f) + outputs = None + + for i, (img, _, _, _) in enumerate(input): + img = img.to(device) + with torch.no_grad(): + features = trip_model.forward_once(img) + + if outputs is None: + outputs = features.cpu() + else: + outputs = torch.cat((outputs, features.cpu()), dim=0) + + pred = clf.predict(outputs) + return pred + diff --git a/recognition/dataset.py b/recognition/dataset.py new file mode 100644 index 000000000..528409213 --- /dev/null +++ b/recognition/dataset.py @@ -0,0 +1,120 @@ +import torch + +import torchvision.transforms as transforms + +import os +from PIL import Image +from torch.utils.data import Dataset, DataLoader +import torch + +class CustomDataset(Dataset): + def __init__(self, root_dir, transform=None): + self.root_dir = root_dir + self.transform = transform + self.image_paths = os.listdir(root_dir) + + def __len__(self): + return len(self.image_paths) + + def __getitem__(self, idx): + img_name = os.path.join(self.root_dir, self.image_paths[idx]) + image = Image.open(img_name) + + if self.transform: + image = self.transform(image) + + return image + +class TripletDataset(Dataset): + def __init__(self, AD, NC, transform=None): + self.X = AD + NC + self.AD = AD + self.NC = NC + self.Y = torch.cat((torch.ones(len(AD)), torch.zeros(len(NC))), dim=0) + self.anc_indices = torch.randperm(len(self.X)) + self.pos_indices = torch.randperm(len(self.X)) % len(AD) + self.neg_indices = torch.randperm(len(self.X)) % len(NC) + self.transform = transform + + def __len__(self): + return len(self.anc_indices) + + def __getitem__(self, idx): + anc = self.anc_indices[idx] + pos = self.pos_indices[idx] + neg = self.neg_indices[idx] + img1 = self.X[anc] + img2 = self.AD[pos] + img3 = self.NC[neg] + label = self.Y[anc] + + if self.transform: + img1 = self.transform(img1) + img2 = self.transform(img2) + img3 = self.transform(img3) + + return img1, img2, img3, torch.tensor([1 - label, label]) + + + + +def intensity_normalization(img, mean = None, std = None): + mean = torch.mean(img) + std = torch.std(img) + return (img - mean) / std + +class CustomNormalize(object): + def __init__(self, mean, std): + self.mean = mean + self.std = std + + def __call__(self, img): + return (img - self.mean) / self.std + +transform_train = transforms.Compose([ + transforms.Resize((256, 256)), + transforms.ToTensor(), + transforms.RandomAffine(degrees=5, translate=(0.05, 0.05), scale=(0.95, 1.05)), # Random affine transformations with smaller parameters + transforms.Lambda(intensity_normalization) +]) + +transform_test = transforms.Compose([ + transforms.Resize((256, 256)), + transforms.ToTensor(), + transforms.Lambda(intensity_normalization) +]) + +class Normalize(object): + def __init__(self, mean, std): + self.mean = mean + self.std = std + + def __call__(self, img): + return (img - self.mean) / self.std + + + +def gen_loaders(root_dir = '', batch_size = 96): + loaders = {} + AD_train = CustomDataset(root_dir=root_dir + os.path.join('train', 'AD'), transform=transform_train) + NC_train = CustomDataset(root_dir=root_dir + os.path.join('train', 'NC'), transform=transform_train) + + X = torch.stack([img for img in AD_train + NC_train]) + mean = X.mean() + std = X.std() + normalize = transforms.Compose([ + Normalize(mean, std) + ]) + train_dataset = TripletDataset(AD_train, NC_train, normalize) + + + # Create DataLoaders for the two parts + loaders['train'] = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) + + AD_test = CustomDataset(root_dir=os.path.join('test', 'AD'), transform=transform_test) + NC_test = CustomDataset(root_dir=os.path.join('test', 'NC'), transform=transform_test) + + test_dataset = TripletDataset(AD_test, NC_test, normalize) + + loaders['test'] = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) + return loaders \ No newline at end of file diff --git a/recognition/modules.py b/recognition/modules.py new file mode 100644 index 000000000..ab28c061c --- /dev/null +++ b/recognition/modules.py @@ -0,0 +1,60 @@ + +import torch +import torch.nn as nn +import torchvision.models as models +import torch.nn.functional as F + +class TripletSiameseNetwork(nn.Module): + def __init__(self, pretrained=True): + super(TripletSiameseNetwork, self).__init__() + self.resnet = models.resnet18(pretrained=pretrained) + self.resnet.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) + self.bn = nn.BatchNorm1d(1000) + self.fc1 = nn.Linear(1000, 128) + + def forward_once(self, x): + output = self.resnet(x) + output = self.bn(output) + output = self.fc1(output) + return output + + def forward(self, anchor, positive, negative): + output_anchor = self.forward_once(anchor) + output_positive = self.forward_once(positive) + output_negative = self.forward_once(negative) + return output_anchor, output_positive, output_negative + +class TripletLoss(nn.Module): + def __init__(self, margin=1.0): + super(TripletLoss, self).__init__() + self.margin = margin + + def forward(self, anchor, positive, negative): + distance_positive = F.pairwise_distance(anchor, positive) + distance_negative = F.pairwise_distance(anchor, negative) + losses = F.relu(distance_positive - distance_negative + self.margin) + return losses.mean() + +class TripletLossWithRegularization(nn.Module): + def __init__(self, model, margin=1.0, lambda_reg=0.0001): + super(TripletLossWithRegularization, self).__init__() + self.model = model + self.margin = margin + self.lambda_reg = lambda_reg # Regularization parameter + + def forward(self, anchor, positive, negative): + distance_positive = F.pairwise_distance(anchor, positive) + distance_negative = F.pairwise_distance(anchor, negative) + triplet_losses = F.relu(distance_positive - distance_negative + self.margin) + triplet_loss = triplet_losses.mean() + + # Compute L2 regularization + l2_reg = None + for param in self.model.parameters(): + if l2_reg is None: + l2_reg = param.norm(2) + else: + l2_reg = l2_reg + param.norm(2) + + loss = triplet_loss + self.lambda_reg * l2_reg + return loss diff --git a/recognition/predict.py b/recognition/predict.py new file mode 100644 index 000000000..936cb25da --- /dev/null +++ b/recognition/predict.py @@ -0,0 +1,26 @@ +from modules import TripletSiameseNetwork +from dataset import gen_loaders +import torch +import pickle + +def predict(input=gen_loaders()['test'], triplet_path = 'trip_model.pth', classifier_path='classifier.pickle'): + device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + trip_model = TripletSiameseNetwork() + trip_model = torch.load(triplet_path) + with open(classifier_path, 'rb') as f: + clf = pickle.load(f) + outputs = None + + for i, (img, _, _, _) in enumerate(input): + img = img.to(device) + with torch.no_grad(): + features = trip_model.forward_once(img) + + if outputs is None: + outputs = features.cpu() + else: + outputs = torch.cat((outputs, features.cpu()), dim=0) + + pred = clf.predict(outputs) + return pred + diff --git a/recognition/train.py b/recognition/train.py new file mode 100644 index 000000000..ae536b1a8 --- /dev/null +++ b/recognition/train.py @@ -0,0 +1,138 @@ +import torch +import torchvision.transforms as transforms +import numpy as np +import matplotlib.pyplot as plt +from dataset import gen_loaders +from modules import TripletSiameseNetwork, TripletLoss, TripletLossWithRegularization +from sklearn.ensemble import RandomForestClassifier +from sklearn.metrics import accuracy_score +import pickle +from itertools import cycle + +loaders = gen_loaders() + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') +learning_rate = 0.001 +trip_model = TripletSiameseNetwork() +trip_criterion = TripletLossWithRegularization(margin=1.0) +val_criterion = TripletLoss(margin=1.0) +total_step = len(loaders['train']) +epochs = 20 + +optimizer = torch.optim.SGD(trip_model.parameters(), lr=learning_rate, momentum=0.9, weight_decay=5e-4) + +sched_linear_1 = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=0.0001, max_lr=learning_rate, step_size_up=epochs // 2, step_size_down=epochs // 2, mode="triangular", verbose=False) +sched_linear_3 = torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=0.0001/learning_rate, end_factor=0.0001/learning_rate, verbose=False) +scheduler = torch.optim.lr_scheduler.SequentialLR(optimizer, schedulers=[sched_linear_1, sched_linear_3], milestones=[epochs]) + + + +test_iter = cycle(iter(loaders['test'])) +trip_model.to(device) +losses = [] +val_losses = [] + +transform_train = transforms.RandomAffine(degrees=5, translate=(0.05, 0.05), scale=(0.95, 1.05)) + +prev_loss = float('inf') +epochs_without_improvement = 0 +max_epochs_without_improvement = 3 + +for epoch in range(epochs): + print(f'Learning rate: {optimizer.param_groups[0]["lr"]}') + losses.append([]) + val_losses.append([]) + for i, (img1, img2, img3, _) in enumerate(loaders['train']): + size = img1.size(0) + img1, img2, img3 = img1[torch.randperm(size)], img2[torch.randperm(size)], img3[torch.randperm(size)] + img1_trans = transform_train(img1) + img2_trans = transform_train(img2) + img3_trans = transform_train(img3) + img1_trans, img2_trans, img3_trans = img1_trans.to(device), img2_trans.to(device), img3_trans.to(device) + + + out1, out2, out3 = trip_model(img1_trans, img2_trans, img3_trans) + + loss = trip_criterion(out1, out2, out3) + optimizer.zero_grad() + loss.backward() + optimizer.step() + + no_loss = val_criterion(out1, out2, out3) + losses[epoch].append(no_loss.item()) + if (i + 1) % (total_step // 10) == 0: + + with torch.no_grad(): + val_img1, val_img2, val_img3, _ = next(test_iter) + val_img1, val_img2, val_img3 = val_img1.to(device), val_img2.to(device), val_img3.to(device) + val_out1, val_out2, val_out3 = trip_model(val_img1, val_img2, val_img3) + val_loss = val_criterion(val_out1, val_out2, val_out3) + val_losses[epoch].append(val_loss.item()) + + print(f"Epoch [{epoch + 1} / {epochs}], Step [{i + 1} / {total_step}], Loss: {np.mean(losses[epoch])}, Validation Loss: {np.mean(val_losses[epoch])}") + + scheduler.step() + mean_list1 = np.mean(losses, axis=1) + mean_list2 = np.mean(val_losses, axis=1) + + # Plot the means + plt.plot(mean_list1, label='Train Loss', marker='o') + plt.plot(mean_list2, label='Val Loss', marker='o') + + plt.xlabel('Epoch') + plt.ylabel('Mean Loss') + plt.legend() + plt.show() + + if np.mean(losses[epoch]) < prev_loss: + epochs_without_improvement = 0 + prev_loss = np.mean(losses[epoch]) + else: + epochs_without_improvement += 1 + print(f'{epochs_without_improvement} / {max_epochs_without_improvement} before early stop.') + + if epochs_without_improvement >= max_epochs_without_improvement: + print(f'Early stopping after {epoch + 1} epochs.') + break + + + + + +output_dict = {} +label_dict = {} +for stage in ['train', 'test']: + outputs = None + labels = None + for i, (img, _, _, label) in enumerate(loaders[stage]): + img, label = img.to(device), label.to(device) + with torch.no_grad(): + features = trip_model.forward_once(img) + + if outputs is None: + outputs = features.cpu() + labels = label.cpu() + else: + outputs = torch.cat((outputs, features.cpu()), dim=0) + labels = torch.cat((labels, label.cpu()), dim=0) + output_dict[stage] = outputs + label_dict[stage] = labels + + +# Example usage: +clf = RandomForestClassifier(n_estimators=400, min_samples_split=300, max_depth=8, critereon='entropy') +clf.fit(output_dict['train'], label_dict['train']) + +y_pred = clf.predict(output_dict['test']) +y_pred_train = clf.predict(output_dict['train']) + + +# Calculate the accuracy of the classifier +print(f"Test accuracy: {accuracy_score(label_dict['test'], y_pred)}, Train accuracy: {accuracy_score(label_dict['train'], y_pred_train)}") + + +trip_model.save('trip_model.pth') +with open('classifier.pickle', 'wb') as f: + pickle.dump(clf, f) + +print('Saved siamese to trip_model.pth and classifier to classifier.pickle') \ No newline at end of file diff --git a/train.png b/train.png new file mode 100644 index 000000000..adf944cdc Binary files /dev/null and b/train.png differ diff --git a/train.py b/train.py new file mode 100644 index 000000000..ae536b1a8 --- /dev/null +++ b/train.py @@ -0,0 +1,138 @@ +import torch +import torchvision.transforms as transforms +import numpy as np +import matplotlib.pyplot as plt +from dataset import gen_loaders +from modules import TripletSiameseNetwork, TripletLoss, TripletLossWithRegularization +from sklearn.ensemble import RandomForestClassifier +from sklearn.metrics import accuracy_score +import pickle +from itertools import cycle + +loaders = gen_loaders() + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') +learning_rate = 0.001 +trip_model = TripletSiameseNetwork() +trip_criterion = TripletLossWithRegularization(margin=1.0) +val_criterion = TripletLoss(margin=1.0) +total_step = len(loaders['train']) +epochs = 20 + +optimizer = torch.optim.SGD(trip_model.parameters(), lr=learning_rate, momentum=0.9, weight_decay=5e-4) + +sched_linear_1 = torch.optim.lr_scheduler.CyclicLR(optimizer, base_lr=0.0001, max_lr=learning_rate, step_size_up=epochs // 2, step_size_down=epochs // 2, mode="triangular", verbose=False) +sched_linear_3 = torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=0.0001/learning_rate, end_factor=0.0001/learning_rate, verbose=False) +scheduler = torch.optim.lr_scheduler.SequentialLR(optimizer, schedulers=[sched_linear_1, sched_linear_3], milestones=[epochs]) + + + +test_iter = cycle(iter(loaders['test'])) +trip_model.to(device) +losses = [] +val_losses = [] + +transform_train = transforms.RandomAffine(degrees=5, translate=(0.05, 0.05), scale=(0.95, 1.05)) + +prev_loss = float('inf') +epochs_without_improvement = 0 +max_epochs_without_improvement = 3 + +for epoch in range(epochs): + print(f'Learning rate: {optimizer.param_groups[0]["lr"]}') + losses.append([]) + val_losses.append([]) + for i, (img1, img2, img3, _) in enumerate(loaders['train']): + size = img1.size(0) + img1, img2, img3 = img1[torch.randperm(size)], img2[torch.randperm(size)], img3[torch.randperm(size)] + img1_trans = transform_train(img1) + img2_trans = transform_train(img2) + img3_trans = transform_train(img3) + img1_trans, img2_trans, img3_trans = img1_trans.to(device), img2_trans.to(device), img3_trans.to(device) + + + out1, out2, out3 = trip_model(img1_trans, img2_trans, img3_trans) + + loss = trip_criterion(out1, out2, out3) + optimizer.zero_grad() + loss.backward() + optimizer.step() + + no_loss = val_criterion(out1, out2, out3) + losses[epoch].append(no_loss.item()) + if (i + 1) % (total_step // 10) == 0: + + with torch.no_grad(): + val_img1, val_img2, val_img3, _ = next(test_iter) + val_img1, val_img2, val_img3 = val_img1.to(device), val_img2.to(device), val_img3.to(device) + val_out1, val_out2, val_out3 = trip_model(val_img1, val_img2, val_img3) + val_loss = val_criterion(val_out1, val_out2, val_out3) + val_losses[epoch].append(val_loss.item()) + + print(f"Epoch [{epoch + 1} / {epochs}], Step [{i + 1} / {total_step}], Loss: {np.mean(losses[epoch])}, Validation Loss: {np.mean(val_losses[epoch])}") + + scheduler.step() + mean_list1 = np.mean(losses, axis=1) + mean_list2 = np.mean(val_losses, axis=1) + + # Plot the means + plt.plot(mean_list1, label='Train Loss', marker='o') + plt.plot(mean_list2, label='Val Loss', marker='o') + + plt.xlabel('Epoch') + plt.ylabel('Mean Loss') + plt.legend() + plt.show() + + if np.mean(losses[epoch]) < prev_loss: + epochs_without_improvement = 0 + prev_loss = np.mean(losses[epoch]) + else: + epochs_without_improvement += 1 + print(f'{epochs_without_improvement} / {max_epochs_without_improvement} before early stop.') + + if epochs_without_improvement >= max_epochs_without_improvement: + print(f'Early stopping after {epoch + 1} epochs.') + break + + + + + +output_dict = {} +label_dict = {} +for stage in ['train', 'test']: + outputs = None + labels = None + for i, (img, _, _, label) in enumerate(loaders[stage]): + img, label = img.to(device), label.to(device) + with torch.no_grad(): + features = trip_model.forward_once(img) + + if outputs is None: + outputs = features.cpu() + labels = label.cpu() + else: + outputs = torch.cat((outputs, features.cpu()), dim=0) + labels = torch.cat((labels, label.cpu()), dim=0) + output_dict[stage] = outputs + label_dict[stage] = labels + + +# Example usage: +clf = RandomForestClassifier(n_estimators=400, min_samples_split=300, max_depth=8, critereon='entropy') +clf.fit(output_dict['train'], label_dict['train']) + +y_pred = clf.predict(output_dict['test']) +y_pred_train = clf.predict(output_dict['train']) + + +# Calculate the accuracy of the classifier +print(f"Test accuracy: {accuracy_score(label_dict['test'], y_pred)}, Train accuracy: {accuracy_score(label_dict['train'], y_pred_train)}") + + +trip_model.save('trip_model.pth') +with open('classifier.pickle', 'wb') as f: + pickle.dump(clf, f) + +print('Saved siamese to trip_model.pth and classifier to classifier.pickle') \ No newline at end of file