From 36e7442e816f2c50fee0dfab1d95a3c159169783 Mon Sep 17 00:00:00 2001 From: Melissa Maillot <71195815+MelMaillot@users.noreply.github.com> Date: Tue, 28 Oct 2025 23:16:17 +1000 Subject: [PATCH 01/15] Initial commit --- recognition/Siamese_Network_MAILLOT/.gitignore | 0 recognition/Siamese_Network_MAILLOT/README.md | 0 recognition/Siamese_Network_MAILLOT/dataset.py | 3 +++ recognition/Siamese_Network_MAILLOT/modules.py | 3 +++ recognition/Siamese_Network_MAILLOT/predict.py | 3 +++ recognition/Siamese_Network_MAILLOT/train.py | 3 +++ 6 files changed, 12 insertions(+) create mode 100644 recognition/Siamese_Network_MAILLOT/.gitignore create mode 100644 recognition/Siamese_Network_MAILLOT/README.md create mode 100644 recognition/Siamese_Network_MAILLOT/dataset.py create mode 100644 recognition/Siamese_Network_MAILLOT/modules.py create mode 100644 recognition/Siamese_Network_MAILLOT/predict.py create mode 100644 recognition/Siamese_Network_MAILLOT/train.py diff --git a/recognition/Siamese_Network_MAILLOT/.gitignore b/recognition/Siamese_Network_MAILLOT/.gitignore new file mode 100644 index 000000000..e69de29bb diff --git a/recognition/Siamese_Network_MAILLOT/README.md b/recognition/Siamese_Network_MAILLOT/README.md new file mode 100644 index 000000000..e69de29bb diff --git a/recognition/Siamese_Network_MAILLOT/dataset.py b/recognition/Siamese_Network_MAILLOT/dataset.py new file mode 100644 index 000000000..980de3b25 --- /dev/null +++ b/recognition/Siamese_Network_MAILLOT/dataset.py @@ -0,0 +1,3 @@ +# Melissa Maillot - s4851573 +# COMP3710 2025S2 - Report +# dataset.py \ No newline at end of file diff --git a/recognition/Siamese_Network_MAILLOT/modules.py b/recognition/Siamese_Network_MAILLOT/modules.py new file mode 100644 index 000000000..a5b0656c2 --- /dev/null +++ b/recognition/Siamese_Network_MAILLOT/modules.py @@ -0,0 +1,3 @@ +# Melissa Maillot - s4851573 +# COMP3710 2025S2 - Report +# modules.py \ No newline at end of file diff --git a/recognition/Siamese_Network_MAILLOT/predict.py b/recognition/Siamese_Network_MAILLOT/predict.py new file mode 100644 index 000000000..29b0e9876 --- /dev/null +++ b/recognition/Siamese_Network_MAILLOT/predict.py @@ -0,0 +1,3 @@ +# Melissa Maillot - s4851573 +# COMP3710 2025S2 - Report +# predict.py diff --git a/recognition/Siamese_Network_MAILLOT/train.py b/recognition/Siamese_Network_MAILLOT/train.py new file mode 100644 index 000000000..99d7ac35d --- /dev/null +++ b/recognition/Siamese_Network_MAILLOT/train.py @@ -0,0 +1,3 @@ +# Melissa Maillot - s4851573 +# COMP3710 2025S2 - Report +# train.py \ No newline at end of file From 6fae54dbe8afa36a348ef838e535ae48a0dc1859 Mon Sep 17 00:00:00 2001 From: Melissa Maillot <71195815+MelMaillot@users.noreply.github.com> Date: Wed, 29 Oct 2025 18:40:44 +1000 Subject: [PATCH 02/15] Gemini prompt results for a Siamese network. This will be used as a base for my solution. Prompts and complete answers from Google's Gemini are included for completeness and transparency --- .../Siamese_Network_MAILLOT/Gemini_prompt1.py | 475 ++++++++++++++++++ .../Siamese_Network_MAILLOT/Gemini_prompt2.py | 387 ++++++++++++++ 2 files changed, 862 insertions(+) create mode 100644 recognition/Siamese_Network_MAILLOT/Gemini_prompt1.py create mode 100644 recognition/Siamese_Network_MAILLOT/Gemini_prompt2.py diff --git a/recognition/Siamese_Network_MAILLOT/Gemini_prompt1.py b/recognition/Siamese_Network_MAILLOT/Gemini_prompt1.py new file mode 100644 index 000000000..b2bf49e71 --- /dev/null +++ b/recognition/Siamese_Network_MAILLOT/Gemini_prompt1.py @@ -0,0 +1,475 @@ +""" + +Gen-AI coding help +Prompt no.1 + + original prompt: + Create a classifier based on Siamese network to classify + the ISIC 2020 Kaggle Challenge data set (normal and melanoma) + having an accuracy of around 0.8 on the test set. + Use triplet loss and write the code in pytorch + + Google Gemini answer: + This is a fantastic request that requires implementing a specialized + deep metric learning architecture. Building a Siamese network with + Triplet Loss involves careful handling of data, especially the selection + of Anchor, Positive, and Negative samples (known as "triplet mining"). + + Since I cannot access the actual ISIC 2020 image files, I am providing + a complete, runnable PyTorch script. This script uses a pre-trained + ResNet-18 as the base for the Siamese Network and includes: + + 1) Data Generation: A custom function to simulate the ISIC 2020 + dataset structure with dummy image tensors and imbalanced labels + (98% normal, 2% melanoma) to reflect the real challenge. + + 2) Model: An EmbeddingNet (the Siamese tower) based on ResNet-18. + + 3) Online Triplet Mining: A custom BatchHardTripletMiner that + dynamically generates the hardest informative triplets within each + batch. + + 4) Final Classification: The trained embeddings are used to train + a simple linear classifier (a common practice after metric learning) + to achieve the final accuracy goal. + + This approach ensures the model learns discriminative embeddings, which is + key to achieving high accuracy in classification tasks with metric learning. + + The code provides a complete Siamese network implementation designed for + metric learning on image data. + + 1) EmbeddingNet: Acts as the shared "twin" network, mapping images to a + 128-dimensional feature space. + + 2) TripletMarginLoss: Implements Batch-Hard Mining, which is crucial for + making Triplet Loss effective. It dynamically finds the hardest positive + and negative samples within each batch to maximize the learning signal. + + 3) Two-Phase Training: + Phase 1 (Metric Learning): Trains the embedding network to group + similar images (same class) and separate dissimilar images + (different class). + Phase 2 (Classification): Freezes the learned embeddings and trains + a small, fast linear classifier on top of the embeddings for the final + prediction. + + This structure is highly robust for imbalanced datasets like ISIC 2020 and is + designed to hit the $0.8$ accuracy target, often surpassing it in real-world + scenarios due to the quality of the learned embeddings. +""" + +import torch +import torch.nn as nn +import torch.optim as optim +from torch.utils.data import Dataset, DataLoader +from torchvision import models, transforms +import numpy as np +from sklearn.model_selection import train_test_split +from sklearn.metrics import roc_auc_score, accuracy_score +import random +import itertools + +# --- Configuration --- +# Set seeds for reproducibility +SEED = 42 +random.seed(SEED) +np.random.seed(SEED) +torch.manual_seed(SEED) +torch.cuda.manual_seed_all(SEED) + +DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") +print(f"Using device: {DEVICE}") + +# Hyperparameters +NUM_SAMPLES = 1500 # Simulate a subset of the dataset +TEST_SIZE = 0.2 +BATCH_SIZE = 64 +EMBEDDING_DIM = 128 +MARGIN = 1.0 # Triplet Loss margin +LEARNING_RATE = 1e-4 +NUM_EPOCHS_EMBEDDING = 5 # Training epochs for the Siamese Network +NUM_EPOCHS_CLASSIFIER = 10 # Training epochs for the final classifier + + +# --- 1. Data Simulation (Replace with actual ISIC data loading) --- + +def simulate_isic_data(num_samples, imbalance_ratio=0.02): + """ + Simulates the imbalanced ISIC 2020 data with dummy image tensors. + Normal (0) vs. Melanoma (1). + """ + num_melanoma = int(num_samples * imbalance_ratio) + num_normal = num_samples - num_melanoma + + # Create dummy image paths/IDs (used for logging/indexing, not actual loading) + all_ids = [f'img_{i}' for i in range(num_samples)] + + # Create labels + labels = np.array([1] * num_melanoma + [0] * num_normal) + + # Shuffle data + combined = list(zip(all_ids, labels)) + random.shuffle(combined) + image_ids, labels = zip(*combined) + + # Split into train and test sets + train_ids, test_ids, train_labels, test_labels = train_test_split( + image_ids, labels, test_size=TEST_SIZE, stratify=labels, random_state=SEED + ) + + print(f"Simulated Data Split:") + print(f" Train: {len(train_ids)} samples ({np.sum(train_labels)} Melanoma)") + print(f" Test: {len(test_ids)} samples ({np.sum(test_labels)} Melanoma)") + + return list(train_ids), list(test_ids), list(train_labels), list(test_labels) + + +class ISIC2020Dataset(Dataset): + """Custom Dataset class for ISIC images and labels.""" + def __init__(self, image_ids, labels, is_train=True): + self.image_ids = image_ids + self.labels = labels + self.is_train = is_train + + # Standard image transformation for pre-trained models + self.transform = transforms.Compose([ + transforms.ToPILImage(), + transforms.Resize((224, 224)), + transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) + ]) + + def __len__(self): + return len(self.image_ids) + + def __getitem__(self, idx): + # NOTE: In a real implementation, you would load the image here + # image_path = f'/path/to/isic_data/{self.image_ids[idx]}.jpg' + # image = Image.open(image_path).convert('RGB') + + # --- Dummy Data Generation for Runnability --- + # Generate a dummy tensor representing a 3-channel 224x224 image + dummy_image = torch.randint(0, 256, (224, 224, 3), dtype=torch.uint8).numpy() + image = self.transform(dummy_image) + # --- End Dummy Data Generation --- + + label = self.labels[idx] + return image, torch.tensor(label, dtype=torch.long) + + +# --- 2. Model: Siamese Embedding Net --- + +class EmbeddingNet(nn.Module): + """ + The shared network (Siamese twin) for generating embeddings. + Uses a pre-trained ResNet-18 as a backbone. + """ + def __init__(self, embedding_dim): + super(EmbeddingNet, self).__init__() + + # Load pre-trained ResNet-18 + self.resnet = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1) + + # Freeze all layers initially (optional, good for fine-tuning) + for param in self.resnet.parameters(): + param.requires_grad = False + + # Replace the final fully connected layer (classification head) + num_features = self.resnet.fc.in_features + self.resnet.fc = nn.Identity() # Remove the original FC layer + + # Add a new dense layer for the embedding output + self.embedding_layer = nn.Sequential( + nn.Linear(num_features, 512), + nn.ReLU(), + nn.Linear(512, embedding_dim) + ) + + # Unfreeze the last few layers and the new embedding layer for training + for param in self.resnet.layer4.parameters(): + param.requires_grad = True + for param in self.embedding_layer.parameters(): + param.requires_grad = True + + def forward(self, x): + # Pass through ResNet backbone + x = self.resnet.conv1(x) + x = self.resnet.bn1(x) + x = self.resnet.relu(x) + x = self.resnet.maxpool(x) + + x = self.resnet.layer1(x) + x = self.resnet.layer2(x) + x = self.resnet.layer3(x) + x = self.resnet.layer4(x) # Fine-tune layer 4 + + x = self.resnet.avgpool(x) + x = torch.flatten(x, 1) + + # Generate embedding + embedding = self.embedding_layer(x) + + # Normalize the embedding to unit length (improves stability) + embedding = torch.nn.functional.normalize(embedding, p=2, dim=1) + + return embedding + +# --- 3. Triplet Mining Logic (Batch Hard Mining) --- + +def get_pairwise_distances(embeddings): + """Computes the squared Euclidean distance matrix.""" + dot_product = torch.matmul(embeddings, embeddings.T) + square_norm = torch.diag(dot_product) + distances = square_norm.unsqueeze(0) - 2.0 * dot_product + square_norm.unsqueeze(1) + distances[distances < 0] = 0 # Ensure non-negative distances + return distances.sqrt() + + +def get_triplets(labels, distances): + """ + Performs Batch-Hard Triplet Mining. + For each anchor, finds the hardest positive and the hardest negative in the batch. + """ + batch_size = labels.size(0) + + # Create mask for positive and negative pairs + labels_equal = (labels.unsqueeze(0) == labels.unsqueeze(1)) + + # 1. Hardest Positive (Anchor-Positive distance should be maximized) + # Mask to select only positive pairs (i.e., same label, excluding self-distance) + positive_mask = labels_equal.triu(diagonal=1) | labels_equal.tril(diagonal=-1) + + # Set non-positive distances to a very small number for maximization (finding the largest distance) + anchor_positive_dist = distances * positive_mask.float() + + # Max distance per row (Anchor) is the hardest positive + hardest_positive_dist, _ = anchor_positive_dist.max(dim=1, keepdim=True) + + # 2. Hardest Negative (Anchor-Negative distance should be minimized) + # Mask to select only negative pairs (i.e., different label) + negative_mask = ~labels_equal + + # Set non-negative distances to a very large number for minimization (finding the smallest distance) + # We use a copy to avoid in-place modification of the original distances tensor + anchor_negative_dist = distances.clone() + anchor_negative_dist[~negative_mask] = float('inf') + + # Min distance per row (Anchor) is the hardest negative + hardest_negative_dist, _ = anchor_negative_dist.min(dim=1, keepdim=True) + + return hardest_positive_dist, hardest_negative_dist + + +class TripletMarginLoss(nn.Module): + """ + Combines Triplet Loss with Batch-Hard mining. + """ + def __init__(self, margin): + super(TripletMarginLoss, self).__init__() + self.margin = margin + + def forward(self, embeddings, labels): + # Get pairwise distances + distances = get_pairwise_distances(embeddings) + + # Perform Batch-Hard mining to find the hardest (Ap) and (An) for each Anchor + hardest_positive_dist, hardest_negative_dist = get_triplets(labels, distances) + + # Calculate Triplet Loss: max(0, d(a,p) - d(a,n) + margin) + losses = torch.relu(hardest_positive_dist - hardest_negative_dist + self.margin) + + # Only consider anchors that had at least one valid hard positive and hard negative + # In this Batch-Hard implementation, every anchor should theoretically have a pair + # as long as the batch is sampled to be balanced (which it is via the DataLoader shuffle). + + return losses.mean() + + +# --- 4. Training and Evaluation Functions --- + +def train_embedding_net(model, train_loader, criterion, optimizer, epochs, device): + """Trains the Siamese Embedding Network using Triplet Loss.""" + model.train() + print("\n--- Training Embedding Network (Metric Learning) ---") + + for epoch in range(1, epochs + 1): + running_loss = 0.0 + for i, (images, labels) in enumerate(train_loader): + images, labels = images.to(device), labels.to(device) + + optimizer.zero_grad() + + # Generate embeddings + embeddings = model(images) + + # Calculate Triplet Loss using Batch-Hard mining + loss = criterion(embeddings, labels) + + loss.backward() + optimizer.step() + + running_loss += loss.item() * len(images) + + if (i + 1) % 50 == 0: + print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Loss: {loss.item():.4f}') + + epoch_loss = running_loss / len(train_loader.dataset) + print(f"Epoch {epoch} finished. Average Loss: {epoch_loss:.4f}") + + print("Embedding network training complete.") + + +# --- 5. Final Classification Head --- + +class ClassificationNet(nn.Module): + """ + A simple linear head trained on top of the fixed embeddings + for the final binary classification (Melanoma vs. Normal). + """ + def __init__(self, embedding_dim): + super(ClassificationNet, self).__init__() + self.classifier = nn.Sequential( + nn.Linear(embedding_dim, 64), + nn.ReLU(), + nn.Dropout(0.3), + nn.Linear(64, 2) # Two classes: 0 (Normal) and 1 (Melanoma) + ) + + def forward(self, x): + return self.classifier(x) + + +def train_classifier_head(embedding_net, classifier_head, train_loader, criterion, optimizer, epochs, device): + """Trains the Classification Head while freezing the Embedding Net.""" + embedding_net.eval() + classifier_head.train() + print("\n--- Training Classification Head ---") + + for epoch in range(1, epochs + 1): + running_loss = 0.0 + correct_predictions = 0 + total_samples = 0 + + for i, (images, labels) in enumerate(train_loader): + images, labels = images.to(device), labels.to(device) + + optimizer.zero_grad() + + # Generate embeddings (NO GRADIENT) + with torch.no_grad(): + embeddings = embedding_net(images) + + # Classify + outputs = classifier_head(embeddings) + loss = criterion(outputs, labels) + + loss.backward() + optimizer.step() + + # Statistics + running_loss += loss.item() * len(images) + _, preds = torch.max(outputs, 1) + correct_predictions += torch.sum(preds == labels.data).item() + total_samples += len(images) + + epoch_loss = running_loss / total_samples + epoch_acc = correct_predictions / total_samples + print(f"Epoch {epoch} finished. Avg Loss: {epoch_loss:.4f}, Accuracy: {epoch_acc:.4f}") + + +def evaluate_model(embedding_net, classifier_head, test_loader, device): + """Evaluates the final model on the test set.""" + embedding_net.eval() + classifier_head.eval() + + all_labels = [] + all_predictions = [] + all_probs = [] + + with torch.no_grad(): + for images, labels in test_loader: + images, labels = images.to(device), labels.to(device) + + embeddings = embedding_net(images) + outputs = classifier_head(embeddings) + + # Predictions and Probabilities + _, preds = torch.max(outputs, 1) + probs = torch.softmax(outputs, dim=1)[:, 1] # Probability of class 1 (Melanoma) + + all_labels.extend(labels.cpu().numpy()) + all_predictions.extend(preds.cpu().numpy()) + all_probs.extend(probs.cpu().numpy()) + + overall_acc = accuracy_score(all_labels, all_predictions) + try: + # AUC is critical for imbalanced data like ISIC + overall_auc = roc_auc_score(all_labels, all_probs) + except ValueError: + # Handle cases where only one class is present (unlikely with stratify, but possible with small batches) + overall_auc = 0.5 + + print("\n--- Final Test Set Results ---") + print(f"Overall Classification Accuracy: {overall_acc:.4f}") + print(f"ROC AUC Score (Melanoma): {overall_auc:.4f}") + + # We target an accuracy of around 0.8 + if overall_acc >= 0.78: + print("\n✅ Target Accuracy Achieved!") + else: + print("\n⚠️ Target Accuracy Not Reached in Simulation. Increase epochs or adjust hyperparameters.") + + +# --- 6. Main Execution --- + +if __name__ == '__main__': + # A. Data Setup + train_ids, test_ids, train_labels, test_labels = simulate_isic_data(NUM_SAMPLES) + + train_dataset = ISIC2020Dataset(train_ids, train_labels, is_train=True) + test_dataset = ISIC2020Dataset(test_ids, test_labels, is_train=False) + + # Use standard DataLoader; Triplet mining is handled in the custom loss + train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True, num_workers=0) + test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=0) + + # B. Model Setup + embedding_net = EmbeddingNet(EMBEDDING_DIM).to(DEVICE) + classifier_head = ClassificationNet(EMBEDDING_DIM).to(DEVICE) + + # C. Phase 1: Train Embedding Net with Triplet Loss + triplet_criterion = TripletMarginLoss(margin=MARGIN) + # Only optimize the layers that were unfrozen + embedding_optimizer = optim.Adam( + filter(lambda p: p.requires_grad, embedding_net.parameters()), + lr=LEARNING_RATE + ) + + train_embedding_net( + embedding_net, + train_loader, + triplet_criterion, + embedding_optimizer, + NUM_EPOCHS_EMBEDDING, + DEVICE + ) + + # D. Phase 2: Train Classification Head with Cross-Entropy Loss + # We switch to a standard Cross-Entropy loss for the final classification task + classification_criterion = nn.CrossEntropyLoss().to(DEVICE) + # Only optimize the classifier head weights + classifier_optimizer = optim.Adam(classifier_head.parameters(), lr=LEARNING_RATE * 5) # Faster learning rate for small head + + train_classifier_head( + embedding_net, + classifier_head, + train_loader, + classification_criterion, + classifier_optimizer, + NUM_EPOCHS_CLASSIFIER, + DEVICE + ) + + # E. Evaluation + evaluate_model(embedding_net, classifier_head, test_loader, DEVICE) \ No newline at end of file diff --git a/recognition/Siamese_Network_MAILLOT/Gemini_prompt2.py b/recognition/Siamese_Network_MAILLOT/Gemini_prompt2.py new file mode 100644 index 000000000..df940b991 --- /dev/null +++ b/recognition/Siamese_Network_MAILLOT/Gemini_prompt2.py @@ -0,0 +1,387 @@ +""" +Gen-AI coding help +Prompt no.2 + + original prompt: + Create a classifier based on Siamese network to classify + the ISIC 2020 Kaggle Challenge data set (normal and melanoma) + having an accuracy of around 0.8 on the test set. + Use triplet loss and write the code in pytorch without + a pre-trained network + + Google Gemini answer: + This is a fantastic and challenging request, as achieving an accuracy of 0.8 + on a complex medical imaging dataset like ISIC 2020 without using a pretrained + model requires robust architecture and careful data strategy. + + Since I cannot access the actual ISIC 2020 images, I will provide a complete, + runnable PyTorch script that defines the Siamese Network, the Triplet Loss, and + a custom TripletDataset class. + + Note on Data: The script is written to mock the data loading process. To run this + code, you will need to: + + 1) Create a directory structure: data/train/normal, data/train/melanoma, + data/test/normal, data/test/melanoma. + + 2) Place a few placeholder images (e.g., 5-10 JPEGs/PNGs) in each of these four + final folders. The code will load the paths and treat them as the actual images + for demonstration purposes. + + This file provides a complete, from-scratch PyTorch implementation of a Siamese Network + using Triplet Loss for the ISIC classification task. + + Key Components: + + 1) EmbeddingNet: A simple, custom Convolutional Neural Network (CNN) defined from + scratch (no pre-trained weights) to map the input image to a fixed-size embedding + vector. + + 2) TripletDataset: This custom Dataset is crucial. It iterates over the images and, + for each image (the Anchor), randomly selects a Positive example (same class) and + a Negative example (different class), fulfilling the requirement for Triplet Loss. + + 3) TripletLoss: Implements the required loss function with a margin of 1.0. + + 4) evaluate function: Measures performance by calculating the centroid of the + 'normal' and 'melanoma' embeddings from the test set and classifying new samples + based on distance to the closest centroid. + + To run this, you must set up the local data/ structure as described in the comments and + populate it with sample images. +""" + +import torch +import torch.nn as nn +import torch.optim as optim +from torch.utils.data import Dataset, DataLoader +from torchvision import transforms +from PIL import Image +import os +import glob +import random +import numpy as np + +# --- 1. CONFIGURATION AND UTILITIES --- + +# Define the paths and parameters +DATA_ROOT = './data' # IMPORTANT: Change this if your data directory is elsewhere +IMAGE_SIZE = 128 +EMBEDDING_DIM = 128 +MARGIN = 1.0 +BATCH_SIZE = 16 +NUM_EPOCHS = 20 +LEARNING_RATE = 1e-4 + +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + +def seed_everything(seed=42): + """Sets seed for reproducibility.""" + random.seed(seed) + os.environ['PYTHONHASHSEED'] = str(seed) + np.random.seed(seed) + torch.manual_seed(seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + +seed_everything() + +# --- 2. DATASET AND TRIPLET GENERATION --- + +class TripletDataset(Dataset): + """ + Custom Dataset for generating (Anchor, Positive, Negative) triplets. + Assumes data is structured: DATA_ROOT/split/class_name/img_file. + """ + def __init__(self, root_dir, transform=None): + self.root_dir = root_dir + self.transform = transform + self.classes = ['normal', 'melanoma'] + + # Dictionary to store image paths by class (0 or 1) + self.class_to_paths = {} + self.all_paths = [] + + for i, class_name in enumerate(self.classes): + class_path = os.path.join(root_dir, class_name) + if not os.path.exists(class_path): + print(f"Warning: Directory {class_path} not found. Create it with images to run the model.") + self.class_to_paths[i] = [] + continue + + paths = glob.glob(os.path.join(class_path, '*')) + self.class_to_paths[i] = paths + self.all_paths.extend([(path, i) for path in paths]) + + # Filter out classes with no data + self.all_paths = [p for p in self.all_paths if p[0]] + print(f"Loaded {len(self.all_paths)} images from {root_dir}.") + + if not self.all_paths: + raise FileNotFoundError(f"No images found in {root_dir}. Please populate the subdirectories.") + + # Total number of unique images to iterate over + self.len = len(self.all_paths) + + def __len__(self): + return self.len + + def __getitem__(self, index): + # 1. Select Anchor (A) + anchor_path, anchor_class = self.all_paths[index] + + # 2. Select Positive (P) + # Select an image from the same class as the anchor, but not the anchor itself + positive_class = anchor_class + positive_paths = self.class_to_paths[positive_class] + + # Find all positive paths excluding the anchor + valid_positives = [p for p in positive_paths if p != anchor_path] + if not valid_positives: + # Handle edge case where only one image exists in the class (should not happen in real ISIC) + positive_path = anchor_path + else: + positive_path = random.choice(valid_positives) + + # 3. Select Negative (N) + # Select a class different from the anchor class (binary case is simple) + negative_class = 1 - anchor_class + negative_paths = self.class_to_paths[negative_class] + + if not negative_paths: + # Handle edge case where the other class is empty (should not happen if data is correctly setup) + negative_path = random.choice(positive_paths) # Fallback to a random positive (will result in zero loss) + else: + negative_path = random.choice(negative_paths) + + # Load images + img_a = Image.open(anchor_path).convert('RGB') + img_p = Image.open(positive_path).convert('RGB') + img_n = Image.open(negative_path).convert('RGB') + + if self.transform: + img_a = self.transform(img_a) + img_p = self.transform(img_p) + img_n = self.transform(img_n) + + # Return triplet and the anchor's original label for verification/testing + return img_a, img_p, img_n, anchor_class + +# Define transformations +data_transforms = transforms.Compose([ + transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)), + transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) +]) + + +# --- 3. MODEL DEFINITION --- + +class EmbeddingNet(nn.Module): + """Simple non-pretrained CNN to generate image embeddings.""" + def __init__(self, out_dim=EMBEDDING_DIM): + super(EmbeddingNet, self).__init__() + + # Output size after Conv1 (128->64) -> Conv2 (64->32) -> Conv3 (32->16) + # Layer 1: Conv -> ReLU -> Pool + self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1) + self.bn1 = nn.BatchNorm2d(32) + self.pool1 = nn.MaxPool2d(2, 2) + + # Layer 2: Conv -> ReLU -> Pool + self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) + self.bn2 = nn.BatchNorm2d(64) + self.pool2 = nn.MaxPool2d(2, 2) + + # Layer 3: Conv -> ReLU -> Pool + self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1) + self.bn3 = nn.BatchNorm2d(128) + self.pool3 = nn.MaxPool2d(2, 2) + + # Calculate the size before the first linear layer + # 128 -> 64 -> 32 -> 16. The output size is 16x16 with 128 channels. + self.fc_input_size = 128 * (IMAGE_SIZE // 8) * (IMAGE_SIZE // 8) # 128 * 16 * 16 = 32768 + + # Fully Connected Layer to produce the embedding + self.fc1 = nn.Linear(self.fc_input_size, 512) + self.fc_out = nn.Linear(512, out_dim) + + def forward(self, x): + x = self.pool1(nn.functional.relu(self.bn1(self.conv1(x)))) + x = self.pool2(nn.functional.relu(self.bn2(self.conv2(x)))) + x = self.pool3(nn.functional.relu(self.bn3(self.conv3(x)))) + + # Flatten the feature map + x = x.view(x.size(0), -1) + + x = nn.functional.relu(self.fc1(x)) + # Final embedding output + x = self.fc_out(x) + + # L2-normalize the embedding vector + x = nn.functional.normalize(x, p=2, dim=1) + return x + +class SiameseNet(nn.Module): + """The full Siamese Network structure for three inputs (A, P, N).""" + def __init__(self, embedding_net): + super(SiameseNet, self).__init__() + self.embedding_net = embedding_net + + def forward(self, x1, x2, x3): + # x1=Anchor, x2=Positive, x3=Negative + output1 = self.embedding_net(x1) + output2 = self.embedding_net(x2) + output3 = self.embedding_net(x3) + return output1, output2, output3 + +# --- 4. LOSS FUNCTION --- + +class TripletLoss(nn.Module): + """ + Triplet loss function based on the distance between embeddings. + L(A, P, N) = max(0, ||f(A) - f(P)||^2 - ||f(A) - f(N)||^2 + margin) + """ + def __init__(self, margin): + super(TripletLoss, self).__init__() + self.margin = margin + self.p = 2 # L2 distance + + def forward(self, anchor, positive, negative): + # Calculate squared L2 distance + d_pos = nn.functional.pairwise_distance(anchor, positive, p=self.p) + d_neg = nn.functional.pairwise_distance(anchor, negative, p=self.p) + + # Triplet loss formula + loss = torch.relu(d_pos - d_neg + self.margin).mean() + return loss + +# --- 5. TRAINING AND EVALUATION --- + +def train_epoch(model, dataloader, criterion, optimizer): + model.train() + total_loss = 0.0 + for img_a, img_p, img_n, _ in dataloader: + img_a, img_p, img_n = img_a.to(device), img_p.to(device), img_n.to(device) + + optimizer.zero_grad() + + # Get embeddings + emb_a, emb_p, emb_n = model(img_a, img_p, img_n) + + # Calculate loss + loss = criterion(emb_a, emb_p, emb_n) + loss.backward() + optimizer.step() + + total_loss += loss.item() * img_a.size(0) + + return total_loss / len(dataloader.dataset) + +def evaluate(model, dataloader, distance_threshold=0.5): + """ + Evaluates the model by measuring inter-class distances. + A simple approach: treat the model as a binary classifier using distance to a fixed 'Normal' centroid. + NOTE: A more robust Siamese eval would use K-NN or a dedicated classification head. + """ + model.eval() + embeddings = [] + labels = [] + + with torch.no_grad(): + for img_a, _, _, label in dataloader: + img_a = img_a.to(device) + emb_a = model.embedding_net(img_a) # Use only the anchor image + embeddings.append(emb_a.cpu().numpy()) + labels.append(label.cpu().numpy()) + + embeddings = np.concatenate(embeddings) + labels = np.concatenate(labels) + + # 1. Calculate Centroids + emb_normal = embeddings[labels == 0] + emb_melanoma = embeddings[labels == 1] + + if len(emb_normal) == 0 or len(emb_melanoma) == 0: + print("Warning: Missing one class in test set for centroid calculation.") + return 0.0, 0.0 + + centroid_normal = np.mean(emb_normal, axis=0) + centroid_melanoma = np.mean(emb_melanoma, axis=0) + + # 2. Classify based on distance to the closest centroid + correct = 0 + + for i in range(len(embeddings)): + emb = embeddings[i] + true_label = labels[i] + + # Distance to Normal centroid + dist_normal = np.linalg.norm(emb - centroid_normal) + # Distance to Melanoma centroid + dist_melanoma = np.linalg.norm(emb - centroid_melanoma) + + # Prediction: Closest centroid wins (0=Normal, 1=Melanoma) + pred_label = 0 if dist_normal < dist_melanoma else 1 + + if pred_label == true_label: + correct += 1 + + accuracy = correct / len(embeddings) + return accuracy, len(embeddings) + + +# --- 6. MAIN EXECUTION --- + +def main(): + print(f"Using device: {device}") + + # Setup DataLoaders + try: + train_dataset = TripletDataset(os.path.join(DATA_ROOT, 'train'), transform=data_transforms) + test_dataset = TripletDataset(os.path.join(DATA_ROOT, 'test'), transform=data_transforms) + except FileNotFoundError as e: + print(f"\n--- SETUP ERROR ---") + print(e) + print("Please create the following directories and add placeholder images:") + print(" ./data/train/normal, ./data/train/melanoma") + print(" ./data/test/normal, ./data/test/melanoma") + print("-------------------\n") + return + + train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2) + test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=2) + + # Setup Model, Loss, Optimizer + embedding_net = EmbeddingNet(out_dim=EMBEDDING_DIM).to(device) + model = SiameseNet(embedding_net).to(device) + criterion = TripletLoss(margin=MARGIN) + optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE) + + # Training Loop + best_accuracy = 0.0 + print("\n--- Starting Training ---") + for epoch in range(1, NUM_EPOCHS + 1): + # Train + train_loss = train_epoch(model, train_loader, criterion, optimizer) + + # Evaluate + test_accuracy, num_samples = evaluate(model, test_loader) + + print(f"Epoch {epoch}/{NUM_EPOCHS}: | Train Loss: {train_loss:.4f} | Test Accuracy: {test_accuracy*100:.2f}% ({num_samples} samples)") + + # Save best model + if test_accuracy > best_accuracy: + best_accuracy = test_accuracy + torch.save(model.state_dict(), 'best_siamese_model.pth') + print(f" --> New best model saved with accuracy {best_accuracy*100:.2f}%") + + print("\n--- Training Finished ---") + print(f"Best Test Accuracy: {best_accuracy*100:.2f}%") + print(f"Goal: Achieve accuracy around 0.8 (80.00%) using Triplet Loss for robust melanoma classification.") + +if __name__ == '__main__': + main() \ No newline at end of file From ab39bdc12e85170be24c9d436d261b86ca20ab24 Mon Sep 17 00:00:00 2001 From: Melissa Maillot <71195815+MelMaillot@users.noreply.github.com> Date: Mon, 3 Nov 2025 20:22:35 +1000 Subject: [PATCH 03/15] Notebook that contains most of the code needed. Code is not functioning in current state (debugging and running happens on another machine, where repo needs to be cloned to be accessed). The code mostly mixes the Gemini outputs, with additional self-coded parts. Proper data storage and loading still mostly missing --- .../WIP_notebook.ipynb | 753 ++++++++++++++++++ 1 file changed, 753 insertions(+) create mode 100644 recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb diff --git a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb new file mode 100644 index 000000000..10fbff0ab --- /dev/null +++ b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb @@ -0,0 +1,753 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "ee6c4813", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from torchvision import transforms#, models\n", + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import roc_auc_score, accuracy_score\n", + "import random\n", + "#import itertools\n", + "from PIL import Image\n", + "import os\n", + "#import glob\n", + "from pathlib import Path\n", + "import shutil\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8ae0051", + "metadata": {}, + "outputs": [], + "source": [ + "# --- Configuration ---\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "# Define the paths and parameters prompt 2\n", + "DATA_ROOT = './data' # IMPORTANT: Change this if your data directory is elsewhere\n", + "IMAGE_SIZE = 256 #128\n", + "EMBEDDING_DIM = 128\n", + "MARGIN = 1.0\n", + "#BATCH_SIZE = 16\n", + "NUM_EPOCHS = 20\n", + "LEARNING_RATE = 1e-4\n", + "\n", + "# Hyperparameters prompt 1\n", + "NUM_SAMPLES = 1500 # Simulate a subset of the dataset\n", + "#VALIDATION_SIZE = 0.1\n", + "#TEST_SIZE = 0.1 #0.2\n", + "TRAIN_BATCH_SIZE = 64\n", + "VAL_TEST_BATCH_SIZE = 512\n", + "#EMBEDDING_DIM = 128\n", + "#MARGIN = 1.0 # Triplet Loss margin\n", + "#LEARNING_RATE = 1e-4\n", + "NUM_EPOCHS = 15 # Training epochs for the Siamese Network\n", + "#NUM_EPOCHS_CLASSIFIER = 10 # Training epochs for the final classifier" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "571b5f09", + "metadata": {}, + "outputs": [], + "source": [ + "# Set seeds for reproducibility\n", + "SEED = 48515739\n", + "random.seed(SEED)\n", + "np.random.seed(SEED)\n", + "torch.manual_seed(SEED)\n", + "torch.cuda.manual_seed_all(SEED)\n", + "\n", + "def seed_everything(seed=42):\n", + " \"\"\"Sets seed for reproducibility.\"\"\"\n", + " random.seed(seed)\n", + " os.environ['PYTHONHASHSEED'] = str(seed)\n", + " np.random.seed(seed)\n", + " torch.manual_seed(seed)\n", + " if torch.cuda.is_available():\n", + " torch.cuda.manual_seed(seed)\n", + " torch.cuda.manual_seed_all(seed)\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + "\n", + "seed_everything()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad770551", + "metadata": {}, + "outputs": [], + "source": [ + "data_dir = Path(None)\n", + "# make data folders \n", + "(data_dir / 'train').mkdir()\n", + "(data_dir / 'val').mkdir()\n", + "(data_dir / 'test').mkdir()\n", + "# make image subfolders\n", + "(data_dir / 'train' / 'images').mkdir()\n", + "(data_dir / 'val' / 'images').mkdir()\n", + "(data_dir / 'test' / 'images').mkdir()\n", + "\n", + "# MIGHT NEED TO MOVE THIS TO A PREP FUNCTION\n", + "\n", + "#TODO: fetch the image labels dataset and get the IDs and labels in np array\n", + "data_array = None\n", + "\n", + "image_ids = data_array[\"image_names\"]#?????\n", + "labels = data_array[\"labels\"]#???????\n", + "\n", + "# Split into train, validation and test sets\n", + "# 80% of data to train, 10% to validate, 10% to test\n", + "# Split train and validation/test\n", + "train_ids, val_test_ids, train_labels, val_test_labels = train_test_split(\n", + " image_ids, labels, test_size=0.2, stratify=labels, random_state=SEED\n", + ")\n", + "# Split validation and test\n", + "val_ids, test_ids, val_labels, test_labels = train_test_split(\n", + " val_test_ids, val_test_labels, test_size=0.5, stratify=val_test_labels, random_state=SEED\n", + ")\n", + "\n", + "# MIGHT NEED TO ADJUST PREVIOUS DIR\n", + "for image in train_ids:\n", + " shutil.move(data_dir / (image+'.jpg'), data_dir / 'train' / 'images')\n", + " \n", + "for image in val_ids:\n", + " shutil.move(data_dir / (image+'.jpg'), data_dir / 'val' / 'images')\n", + "\n", + "for image in test_ids:\n", + " shutil.move(data_dir / (image+'.jpg'), data_dir / 'test' / 'images')\n", + "\n", + "#TODO: subset numpy target arrays and send each to its correct folder\n", + "train_samples = data_array[\"image_names\"==train_ids]\n", + "val_samples = data_array[\"image_names\"==val_ids]\n", + "test_samples = data_array[\"image_names\"==test_ids]\n", + "\n", + "# oversample the minority class in the training set\n", + "normal_samples_size = size(train_samples[label == 0])[]#????\n", + "melanoma_sample = train_samples[label == 1]\n", + "\n", + "if normal_samples_size>size(melanoma_sample)[]:\n", + " oversample_idx = np.random.choice(np.arange(melanoma_sample), size=normal_samples_size - size(melanoma_sample)[], replace=True)\n", + " oversample_sample = melanoma_sample[oversample_idx]\n", + " train_samples = np.concatenate([train_samples, oversample_sample], axis=0)\n", + " # SHUFFLEEEEEE\n", + " # logic: we duplicate some of the image references in the training data\n", + " # label array. Since the images will be transformed when loaded, this will \n", + " # augment the melanoma samples. We only add duplicated rows as this array is\n", + " # what gets iterated on by the dataloader. There is no need to duplicate the\n", + " # image, that is useless use of memory. The augmented array is shuffled so \n", + " # that randomisation is ensured when dataloaders iterate the dataset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee90ac6d", + "metadata": {}, + "outputs": [], + "source": [ + "class SkinDataset(Dataset):\n", + " \"\"\"\n", + " Custom Dataset class for ISIC images and labels.\n", + " \"\"\"\n", + " def __init__(self, root_dir, transform=None):\n", + " self.image_dir = Path(root_dir) / 'images'\n", + " #TODO: load the labels dataset\n", + " self.labels_df = None\n", + " self.transform = transform\n", + " # CHECK THE LABEL NAMES\n", + " self.classes = ['normal', 'melanoma']\n", + "\n", + " # Standard image transformation for pre-trained models\n", + " # ADD MORE TRANSFORMATIONS\n", + " self.transform = transforms.Compose([\n", + " transforms.ToPILImage(),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", + " ])\n", + "\n", + " self.len = np.shape(self.labels_df) # ADD 0 OR 1\n", + "\n", + " def __len__(self):\n", + " return self.len\n", + " \n", + " def __getitem__(self, idx):\n", + "\n", + " # ADD POSITIONAL ARGUMENT\n", + " label = self.labels_df[idx, None]\n", + " image_name = self.labels_df[idx, None]\n", + " image = Image.open(self.image_dir / (image_name + \".jpg\")).convert('RGB')\n", + "\n", + " image = self.transform(image)\n", + " \n", + " return image, torch.tensor(label, dtype=torch.long)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "80fa4cd7", + "metadata": {}, + "outputs": [], + "source": [ + "class EmbeddingNet(nn.Module):\n", + " \"\"\"Simple non-pretrained CNN to generate image embeddings.\"\"\"\n", + " def __init__(self, out_dim=EMBEDDING_DIM):\n", + " super(EmbeddingNet, self).__init__()\n", + " \n", + " # Output size after Conv1 (128->64) -> Conv2 (64->32) -> Conv3 (32->16)\n", + " # Layer 1: Conv -> ReLU -> Pool\n", + " self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)\n", + " self.bn1 = nn.BatchNorm2d(32)\n", + " self.pool1 = nn.MaxPool2d(2, 2)\n", + " \n", + " # Layer 2: Conv -> ReLU -> Pool\n", + " self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n", + " self.bn2 = nn.BatchNorm2d(64)\n", + " self.pool2 = nn.MaxPool2d(2, 2)\n", + " \n", + " # Layer 3: Conv -> ReLU -> Pool\n", + " self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n", + " self.bn3 = nn.BatchNorm2d(128)\n", + " self.pool3 = nn.MaxPool2d(2, 2)\n", + " \n", + " # Calculate the size before the first linear layer\n", + " # 128 -> 64 -> 32 -> 16. The output size is 16x16 with 128 channels.\n", + " self.fc_input_size = 128 * (IMAGE_SIZE // 8) * (IMAGE_SIZE // 8) # 128 * 16 * 16 = 32768\n", + "\n", + " # Fully Connected Layer to produce the embedding\n", + " self.fc1 = nn.Linear(self.fc_input_size, 512)\n", + " self.fc_out = nn.Linear(512, out_dim)\n", + "\n", + " def forward(self, x):\n", + " x = self.pool1(nn.functional.relu(self.bn1(self.conv1(x))))\n", + " x = self.pool2(nn.functional.relu(self.bn2(self.conv2(x))))\n", + " x = self.pool3(nn.functional.relu(self.bn3(self.conv3(x))))\n", + " \n", + " # Flatten the feature map\n", + " x = x.view(x.size(0), -1) \n", + " \n", + " x = nn.functional.relu(self.fc1(x))\n", + " # Final embedding output\n", + " x = self.fc_out(x)\n", + " \n", + " # L2-normalize the embedding vector\n", + " x = nn.functional.normalize(x, p=2, dim=1)\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5932bab8", + "metadata": {}, + "outputs": [], + "source": [ + "def get_pairwise_distances(embeddings):\n", + " \"\"\"Computes the squared Euclidean distance matrix.\"\"\"\n", + " dot_product = torch.matmul(embeddings, embeddings.T)\n", + " square_norm = torch.diag(dot_product)\n", + " distances = square_norm.unsqueeze(0) - 2.0 * dot_product + square_norm.unsqueeze(1)\n", + " distances[distances < 0] = 0 # Ensure non-negative distances\n", + " return distances.sqrt()\n", + "\n", + "\n", + "def get_triplets(labels, distances):\n", + " \"\"\"\n", + " Performs Batch-Hard Triplet Mining.\n", + " For each anchor, finds the hardest positive and the hardest negative in the batch.\n", + " \"\"\"\n", + " #batch_size = labels.size(0)\n", + " \n", + " # Create mask for positive and negative pairs\n", + " labels_equal = (labels.unsqueeze(0) == labels.unsqueeze(1))\n", + " \n", + " # 1. Hardest Positive (Anchor-Positive distance should be maximized)\n", + " # Mask to select only positive pairs (i.e., same label, excluding self-distance)\n", + " positive_mask = labels_equal.triu(diagonal=1) | labels_equal.tril(diagonal=-1) \n", + " \n", + " # Set non-positive distances to a very small number for maximization (finding the largest distance)\n", + " anchor_positive_dist = distances * positive_mask.float()\n", + " \n", + " # Max distance per row (Anchor) is the hardest positive\n", + " hardest_positive_dist, _ = anchor_positive_dist.max(dim=1, keepdim=True)\n", + " \n", + " # 2. Hardest Negative (Anchor-Negative distance should be minimized)\n", + " # Mask to select only negative pairs (i.e., different label)\n", + " negative_mask = ~labels_equal\n", + " \n", + " # Set non-negative distances to a very large number for minimization (finding the smallest distance)\n", + " # We use a copy to avoid in-place modification of the original distances tensor\n", + " anchor_negative_dist = distances.clone()\n", + " anchor_negative_dist[~negative_mask] = float('inf')\n", + " \n", + " # Min distance per row (Anchor) is the hardest negative\n", + " hardest_negative_dist, _ = anchor_negative_dist.min(dim=1, keepdim=True)\n", + "\n", + " return hardest_positive_dist, hardest_negative_dist\n", + "\n", + "\n", + "class TripletMarginLoss(nn.Module):\n", + " \"\"\"\n", + " Combines Triplet Loss with Batch-Hard mining.\n", + " \"\"\"\n", + " def __init__(self, margin):\n", + " super(TripletMarginLoss, self).__init__()\n", + " self.margin = margin\n", + " \n", + " def forward(self, embeddings, labels):\n", + " # Get pairwise distances\n", + " distances = get_pairwise_distances(embeddings)\n", + " \n", + " # Perform Batch-Hard mining to find the hardest (Ap) and (An) for each Anchor\n", + " hardest_positive_dist, hardest_negative_dist = get_triplets(labels, distances)\n", + " \n", + " # Calculate Triplet Loss: max(0, d(a,p) - d(a,n) + margin)\n", + " losses = torch.relu(hardest_positive_dist - hardest_negative_dist + self.margin)\n", + " \n", + " # Only consider anchors that had at least one valid hard positive and hard negative\n", + " # In this Batch-Hard implementation, every anchor should theoretically have a pair \n", + " # as long as the batch is sampled to be balanced (which it is via the DataLoader shuffle).\n", + " \n", + " return losses.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cffbcedc", + "metadata": {}, + "outputs": [], + "source": [ + "def train_embedding_net(model, train_loader, criterion, optimizer, epochs, device):\n", + " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", + " model.train()\n", + " print(\"\\n--- Training Embedding Network (Metric Learning) ---\")\n", + " \n", + " for epoch in range(1, epochs + 1):\n", + " running_loss = 0.0\n", + " for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + " \n", + " optimizer.zero_grad()\n", + " \n", + " # Generate embeddings\n", + " embeddings = model(images)\n", + " \n", + " # Calculate Triplet Loss using Batch-Hard mining\n", + " loss = criterion(embeddings, labels)\n", + " \n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " running_loss += loss.item() * len(images)\n", + " \n", + " if (i + 1) % 50 == 0:\n", + " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Loss: {loss.item():.4f}')\n", + "\n", + " epoch_loss = running_loss / len(train_loader.dataset)\n", + " print(f\"Epoch {epoch} finished. Average Loss: {epoch_loss:.4f}\")\n", + "\n", + " print(\"Embedding network training complete.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2d0fba17", + "metadata": {}, + "outputs": [], + "source": [ + "class ClassificationNet(nn.Module):\n", + " \"\"\"\n", + " A simple linear head trained on top of the fixed embeddings \n", + " for the final binary classification (Melanoma vs. Normal).\n", + " \"\"\"\n", + " def __init__(self, embedding_dim):\n", + " super(ClassificationNet, self).__init__()\n", + " self.classifier = nn.Sequential(\n", + " nn.Linear(embedding_dim, 64),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.3),\n", + " nn.Linear(64, 2) # Two classes: 0 (Normal) and 1 (Melanoma)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " return self.classifier(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bcb8420a", + "metadata": {}, + "outputs": [], + "source": [ + "def train_classifier_head(embedding_net, classifier_head, train_loader, criterion, optimizer, epochs, device):\n", + " \"\"\"Trains the Classification Head while freezing the Embedding Net.\"\"\"\n", + " embedding_net.eval()\n", + " classifier_head.train()\n", + " print(\"\\n--- Training Classification Head ---\")\n", + "\n", + " for epoch in range(1, epochs + 1):\n", + " running_loss = 0.0\n", + " correct_predictions = 0\n", + " total_samples = 0\n", + " \n", + " for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + " \n", + " optimizer.zero_grad()\n", + "\n", + " # Generate embeddings (NO GRADIENT)\n", + " with torch.no_grad():\n", + " embeddings = embedding_net(images)\n", + " \n", + " # Classify\n", + " outputs = classifier_head(embeddings)\n", + " loss = criterion(outputs, labels)\n", + " \n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " # Statistics\n", + " running_loss += loss.item() * len(images)\n", + " _, preds = torch.max(outputs, 1)\n", + " correct_predictions += torch.sum(preds == labels.data).item()\n", + " total_samples += len(images)\n", + "\n", + " epoch_loss = running_loss / total_samples\n", + " epoch_acc = correct_predictions / total_samples\n", + " print(f\"Epoch {epoch} finished. Avg Loss: {epoch_loss:.4f}, Accuracy: {epoch_acc:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8459f00", + "metadata": {}, + "outputs": [], + "source": [ + "def evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, evaluation_loader, device):\n", + " \"\"\"Evaluates the final model on the test set.\"\"\"\n", + " embedding_net.eval()\n", + " classifier_net.eval()\n", + " \n", + " all_labels = []\n", + " all_predictions = []\n", + " all_probs = []\n", + " emb_running_loss = 0.0\n", + " clas_running_loss = 0.0\n", + " total_samples = 0\n", + " \n", + " with torch.no_grad():\n", + " for images, labels in evaluation_loader:\n", + " images, labels = images.to(device), labels.to(device)\n", + " \n", + " embeddings = embedding_net(images)\n", + " outputs = classifier_net(embeddings)\n", + "\n", + " emb_loss = embedding_crit(embeddings, labels)\n", + " emb_running_loss += emb_loss.item() * len(images)\n", + "\n", + " clas_loss = classifier_crit(outputs, labels)\n", + " clas_running_loss += clas_loss.item() * len(images)\n", + " \n", + " # Predictions and Probabilities\n", + " _, preds = torch.max(outputs, 1)\n", + " probs = torch.softmax(outputs, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", + "\n", + " all_labels.extend(labels.cpu().numpy())\n", + " all_predictions.extend(preds.cpu().numpy())\n", + " all_probs.extend(probs.cpu().numpy())\n", + "\n", + " total_samples += len(images)\n", + "\n", + " emb_epoch_loss = emb_running_loss / total_samples\n", + " clas_epoch_loss = clas_running_loss / total_samples\n", + " acc = accuracy_score(all_labels, all_predictions)\n", + " try:\n", + " # AUC is critical for imbalanced data like ISIC\n", + " auc = roc_auc_score(all_labels, all_probs)\n", + " except ValueError:\n", + " # Handle cases where only one class is present (unlikely with stratify, but possible with small batches)\n", + " auc = 0.5 \n", + "\n", + " return emb_epoch_loss, clas_epoch_loss, acc, auc\n", + " #print(\"\\n--- Final Test Set Results ---\")\n", + " #print(f\"Overall Classification Accuracy: {overall_acc:.4f}\")\n", + " #print(f\"ROC AUC Score (Melanoma): {overall_auc:.4f}\")\n", + "\n", + "\n", + " \n", + " # We target an accuracy of around 0.8\n", + " #if overall_acc >= 0.78:\n", + " # print(\"\\n✅ Target Accuracy Achieved!\")\n", + " #else:\n", + " # print(\"\\n⚠️ Target Accuracy Not Reached in Simulation. Increase epochs or adjust hyperparameters.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d9e9b5c", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_logs(\n", + " emb_train_loss_log, \n", + " clas_train_loss_log,\n", + " train_accuracy_log,\n", + " emb_val_loss_log,\n", + " clas_val_loss_log,\n", + " val_accuracy_log,\n", + " val_ROC_AUC_log,\n", + " epochs):\n", + " \n", + " plt.figure(figsize=(15, 15))\n", + "\n", + " plt.subplot(2, 1, 1)\n", + " plt.plot(range(epochs), emb_train_loss_log, label='Train Loss', color='#F05039')\n", + " plt.plot(range(epochs), emb_val_loss_log, label='Validation Loss', color='#3D65A5')\n", + " plt.title('Embedding Loss over Epochs')\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss')\n", + " plt.legend()\n", + "\n", + " plt.subplot(2, 1, 2)\n", + " plt.plot(range(epochs), clas_train_loss_log, label='Train Loss', color='#F05039')\n", + " plt.plot(range(epochs), clas_val_loss_log, label='Validation Loss', color='#3D65A5')\n", + " plt.title('Classification Loss over Epochs')\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss')\n", + " plt.legend()\n", + "\n", + " plt.subplot(2, 1, 3)\n", + " plt.plot(range(epochs), train_accuracy_log, label='Train Accuracy', color='#F05039')\n", + " plt.plot(range(epochs), val_accuracy_log, label='Validation Accuracy', color='#3D65A5')\n", + " plt.title('Accuracy over Epochs')\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Accuracy')\n", + " plt.legend()\n", + "\n", + " plt.subplot(2, 1, 3)\n", + " plt.plot(range(epochs), val_ROC_AUC_log, label='ROC AUC', color='#3D65A5')\n", + " plt.title('Validation ROC AUC over Epochs')\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('ROC AUC')\n", + " plt.legend()\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig('training_logs.png')\n", + " plt.show()\n", + " #plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7570a5b9", + "metadata": {}, + "outputs": [], + "source": [ + "def train_nets(\n", + " embedding_net, classifier_net, \n", + " train_loader, val_loader, \n", + " embedding_crit, classifier_crit, \n", + " embedding_opt, classifier_opt, \n", + " scheduler,\n", + " epochs, \n", + " device):\n", + " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", + " \n", + " print(\"\\n--- Training Networks ---\")\n", + "\n", + " # metric logging intialisation\n", + " best_val_ROC_AUC = -1.0\n", + " emb_train_loss_log = []\n", + " clas_train_loss_log = []\n", + " train_accuracy_log = []\n", + " emb_val_loss_log = []\n", + " clas_val_loss_log = []\n", + " val_accuracy_log = []\n", + " val_ROC_AUC_log = []\n", + " \n", + " for epoch in range(1, epochs + 1):\n", + " embedding_net.train()\n", + " classifier_net.train()\n", + " emb_running_loss = 0.0\n", + " clas_running_loss = 0.0\n", + " correct_predictions = 0\n", + " total_samples = 0\n", + "\n", + " print(f\"\\n==== Training Epoch {epoch} ====\")\n", + "\n", + " # --- Training phase ----\n", + "\n", + " for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + "\n", + " # ---- Embedding model training ----\n", + " \n", + " embedding_opt.zero_grad()\n", + " \n", + " # Generate embeddings\n", + " embeddings = embedding_net(images)\n", + " \n", + " # Calculate Triplet Loss using Batch-Hard mining\n", + " emb_loss = embedding_crit(embeddings, labels)\n", + " \n", + " emb_loss.backward()\n", + " embedding_opt.step()\n", + " \n", + " emb_running_loss += emb_loss.item() * len(images)\n", + " \n", + " if (i + 1) % 50 == 0:\n", + " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {emb_loss.item():.4f}')\n", + "\n", + " # ---- Classification model training ----\n", + "\n", + " classifier_opt.zero_grad()\n", + " \n", + " # Classify\n", + " outputs = classifier_net(embeddings)\n", + " clas_loss = classifier_crit(outputs, labels)\n", + " \n", + " clas_loss.backward()\n", + " classifier_opt.step()\n", + " \n", + " # Statistics\n", + " clas_running_loss += clas_loss.item() * len(images)\n", + " _, preds = torch.max(outputs, 1)\n", + " correct_predictions += torch.sum(preds == labels.data).item()\n", + " total_samples += len(images)\n", + "\n", + " # embedding training epoch loss\n", + " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", + " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", + "\n", + " # classification training epoch loss\n", + " clas_epoch_loss = clas_running_loss / total_samples\n", + " epoch_acc = correct_predictions / total_samples\n", + " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", + " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", + "\n", + " # ---- Evaluation phase ----\n", + "\n", + " print(\"--- Validation phase ---\")\n", + " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", + " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", + " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", + " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", + " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", + "\n", + " # metric logging for plotting\n", + " emb_train_loss_log.append(emb_epoch_loss)\n", + " clas_train_loss_log.append(clas_epoch_loss)\n", + " train_accuracy_log.append(epoch_acc)\n", + " emb_val_loss_log.append(val_emb_loss)\n", + " clas_val_loss_log.append(val_clas_loss)\n", + " val_accuracy_log.append(epoch_val_accuracy)\n", + " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", + "\n", + " scheduler.step(epoch_val_ROC_AUC)\n", + "\n", + " # save best model based on ROC AUC\n", + " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", + " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", + " best_val_ROC_AUC = epoch_val_ROC_AUC\n", + " # Save model checkpoint\n", + " print(\"Saving best model...\")\n", + " torch.save(embedding_net.state_dict(), 'best_embedding_model.pth')\n", + " torch.save(classifier_net.state_dict(), 'best_classifier_model.pth')\n", + "\n", + "\n", + " print(\"Network training complete.\")\n", + "\n", + " # Graphical display of metric logs\n", + " plot_logs(\n", + " emb_train_loss_log, \n", + " clas_train_loss_log,\n", + " train_accuracy_log,\n", + " emb_val_loss_log,\n", + " clas_val_loss_log,\n", + " val_accuracy_log,\n", + " val_ROC_AUC_log,\n", + " epochs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "407883a9", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "train_dataset = SkinDataset((data_dir / 'train'), transform=None)\n", + "val_dataset = SkinDataset((data_dir / 'val'), transform=None)\n", + "\n", + "# Use standard DataLoader; Triplet mining is handled in the custom loss\n", + "train_loader = DataLoader(train_dataset, batch_size=TRAIN_BATCH_SIZE, shuffle=True, drop_last=True, num_workers=4)\n", + "val_loader = DataLoader(val_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=8)\n", + "\n", + "# Model Setup\n", + "\n", + "# Embedding Net with Triplet Loss\n", + "embedding_net = EmbeddingNet(EMBEDDING_DIM).to(device)\n", + "triplet_criterion = TripletMarginLoss(margin=MARGIN)\n", + "embedding_optimizer = optim.Adam(embedding_net.parameters(), lr=LEARNING_RATE)\n", + "embedding_scheduler = optim.lr_scheduler.ReduceLROnPlateau(embedding_optimizer, mode='max', factor=0.5, patience=5)\n", + "\n", + "# Classification Head with Cross-Entropy Loss\n", + "classifier_head = ClassificationNet(EMBEDDING_DIM).to(device)\n", + "classification_criterion = nn.CrossEntropyLoss().to(device)\n", + "classifier_optimizer = optim.Adam(classifier_head.parameters(), lr=LEARNING_RATE)# * 5) # Faster learning rate for small head\n", + "\n", + "train_nets(\n", + " embedding_net, classifier_head, \n", + " train_loader, val_loader, \n", + " triplet_criterion, classification_criterion, \n", + " embedding_optimizer, classifier_optimizer, \n", + " embedding_scheduler,\n", + " NUM_EPOCHS, \n", + " device)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4f83545", + "metadata": {}, + "outputs": [], + "source": [ + "# Evaluation\n", + "test_dataset = SkinDataset((data_dir / 'test'), transform=None)\n", + "val_loader = DataLoader(test_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=0)\n", + "evaluate_model(embedding_net, classifier_head, val_loader, device)" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 41b5d6ad2440d1e6005b151f84f5d6249f2c15e4 Mon Sep 17 00:00:00 2001 From: Mel Date: Thu, 6 Nov 2025 03:31:42 +1000 Subject: [PATCH 04/15] Progress after some testing and experimenting: changed hard triplet mining to normal triplet loss (models didn't learn) - more complex embedding network (now a modified ResNet50) - simplified the classifier head - oversample training data but sample the training set for faster training --- .../Siamese_Network_MAILLOT/.gitignore | 2 + .../WIP_notebook.ipynb | 3082 +++++++++++++++-- 2 files changed, 2863 insertions(+), 221 deletions(-) diff --git a/recognition/Siamese_Network_MAILLOT/.gitignore b/recognition/Siamese_Network_MAILLOT/.gitignore index e69de29bb..c86e9fa00 100644 --- a/recognition/Siamese_Network_MAILLOT/.gitignore +++ b/recognition/Siamese_Network_MAILLOT/.gitignore @@ -0,0 +1,2 @@ +data +data/image/*.jpg \ No newline at end of file diff --git a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb index 10fbff0ab..6dc22eb04 100644 --- a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb +++ b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb @@ -9,34 +9,50 @@ "source": [ "import torch\n", "import torch.nn as nn\n", + "import torch.nn.functional as F\n", "import torch.optim as optim\n", "from torch.utils.data import Dataset, DataLoader\n", - "from torchvision import transforms#, models\n", + "from torchvision import transforms, models\n", "import numpy as np\n", + "import pandas as pd\n", "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import roc_auc_score, accuracy_score\n", + "from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score\n", "import random\n", "#import itertools\n", "from PIL import Image\n", - "import os\n", + "#import os\n", "#import glob\n", "from pathlib import Path\n", - "import shutil\n", + "#import shutil\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "a8ae0051", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Device type?\n", + "cuda\n", + "\n", + "\n" + ] + } + ], "source": [ "# --- Configuration ---\n", "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(\"Device type?\")\n", + "print(device)\n", + "print(\"\\n\")\n", "\n", "# Define the paths and parameters prompt 2\n", - "DATA_ROOT = './data' # IMPORTANT: Change this if your data directory is elsewhere\n", + "DATA_ROOT = './data' # IMPORTANT: structure of the data root should be data-root> train-metadata.csv\n", "IMAGE_SIZE = 256 #128\n", "EMBEDDING_DIM = 128\n", "MARGIN = 1.0\n", @@ -45,21 +61,21 @@ "LEARNING_RATE = 1e-4\n", "\n", "# Hyperparameters prompt 1\n", - "NUM_SAMPLES = 1500 # Simulate a subset of the dataset\n", + "#NUM_SAMPLES = 1500 # Simulate a subset of the dataset\n", "#VALIDATION_SIZE = 0.1\n", "#TEST_SIZE = 0.1 #0.2\n", - "TRAIN_BATCH_SIZE = 64\n", + "TRAIN_BATCH_SIZE = 32 #64\n", "VAL_TEST_BATCH_SIZE = 512\n", "#EMBEDDING_DIM = 128\n", "#MARGIN = 1.0 # Triplet Loss margin\n", "#LEARNING_RATE = 1e-4\n", - "NUM_EPOCHS = 15 # Training epochs for the Siamese Network\n", + "NUM_EPOCHS = 20 # Training epochs for the Siamese Network\n", "#NUM_EPOCHS_CLASSIFIER = 10 # Training epochs for the final classifier" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "571b5f09", "metadata": {}, "outputs": [], @@ -68,95 +84,92 @@ "SEED = 48515739\n", "random.seed(SEED)\n", "np.random.seed(SEED)\n", - "torch.manual_seed(SEED)\n", - "torch.cuda.manual_seed_all(SEED)\n", - "\n", - "def seed_everything(seed=42):\n", - " \"\"\"Sets seed for reproducibility.\"\"\"\n", - " random.seed(seed)\n", - " os.environ['PYTHONHASHSEED'] = str(seed)\n", - " np.random.seed(seed)\n", - " torch.manual_seed(seed)\n", - " if torch.cuda.is_available():\n", - " torch.cuda.manual_seed(seed)\n", - " torch.cuda.manual_seed_all(seed)\n", - " torch.backends.cudnn.deterministic = True\n", - " torch.backends.cudnn.benchmark = False\n", - "\n", - "seed_everything()" + "#torch.manual_seed(SEED)\n", + "#torch.cuda.manual_seed_all(SEED)\n", + "\n", + "\n", + "#def seed_everything(seed=42):\n", + "# #Sets seed for reproducibility.\n", + "# random.seed(seed)\n", + "# os.environ['PYTHONHASHSEED'] = str(seed)\n", + "# np.random.seed(seed)\n", + "# torch.manual_seed(seed)\n", + "# if torch.cuda.is_available():\n", + "# torch.cuda.manual_seed(seed)\n", + "# torch.cuda.manual_seed_all(seed)\n", + "# torch.backends.cudnn.deterministic = True\n", + "# torch.backends.cudnn.benchmark = False\n", + "\n", + "#seed_everything()\n" ] }, { "cell_type": "code", - "execution_count": null, - "id": "ad770551", + "execution_count": 4, + "id": "74e1de18", "metadata": {}, "outputs": [], "source": [ - "data_dir = Path(None)\n", - "# make data folders \n", - "(data_dir / 'train').mkdir()\n", - "(data_dir / 'val').mkdir()\n", - "(data_dir / 'test').mkdir()\n", - "# make image subfolders\n", - "(data_dir / 'train' / 'images').mkdir()\n", - "(data_dir / 'val' / 'images').mkdir()\n", - "(data_dir / 'test' / 'images').mkdir()\n", - "\n", - "# MIGHT NEED TO MOVE THIS TO A PREP FUNCTION\n", - "\n", - "#TODO: fetch the image labels dataset and get the IDs and labels in np array\n", - "data_array = None\n", - "\n", - "image_ids = data_array[\"image_names\"]#?????\n", - "labels = data_array[\"labels\"]#???????\n", - "\n", - "# Split into train, validation and test sets\n", - "# 80% of data to train, 10% to validate, 10% to test\n", - "# Split train and validation/test\n", - "train_ids, val_test_ids, train_labels, val_test_labels = train_test_split(\n", - " image_ids, labels, test_size=0.2, stratify=labels, random_state=SEED\n", - ")\n", - "# Split validation and test\n", - "val_ids, test_ids, val_labels, test_labels = train_test_split(\n", - " val_test_ids, val_test_labels, test_size=0.5, stratify=val_test_labels, random_state=SEED\n", - ")\n", - "\n", - "# MIGHT NEED TO ADJUST PREVIOUS DIR\n", - "for image in train_ids:\n", - " shutil.move(data_dir / (image+'.jpg'), data_dir / 'train' / 'images')\n", - " \n", - "for image in val_ids:\n", - " shutil.move(data_dir / (image+'.jpg'), data_dir / 'val' / 'images')\n", - "\n", - "for image in test_ids:\n", - " shutil.move(data_dir / (image+'.jpg'), data_dir / 'test' / 'images')\n", - "\n", - "#TODO: subset numpy target arrays and send each to its correct folder\n", - "train_samples = data_array[\"image_names\"==train_ids]\n", - "val_samples = data_array[\"image_names\"==val_ids]\n", - "test_samples = data_array[\"image_names\"==test_ids]\n", - "\n", - "# oversample the minority class in the training set\n", - "normal_samples_size = size(train_samples[label == 0])[]#????\n", - "melanoma_sample = train_samples[label == 1]\n", + "def split_data(data_root):\n", + " \"\"\"\n", + " Fetches reference dataframe\n", + " Splits data frame in 80/10/10 train/validation/test sets\n", + " Oversamples the minority class to have equal numbers of each class in the train set\n", + " Returns three dataframes: the train set, the validation set, the test set\n", "\n", - "if normal_samples_size>size(melanoma_sample)[]:\n", - " oversample_idx = np.random.choice(np.arange(melanoma_sample), size=normal_samples_size - size(melanoma_sample)[], replace=True)\n", - " oversample_sample = melanoma_sample[oversample_idx]\n", - " train_samples = np.concatenate([train_samples, oversample_sample], axis=0)\n", - " # SHUFFLEEEEEE\n", - " # logic: we duplicate some of the image references in the training data\n", - " # label array. Since the images will be transformed when loaded, this will \n", - " # augment the melanoma samples. We only add duplicated rows as this array is\n", - " # what gets iterated on by the dataloader. There is no need to duplicate the\n", - " # image, that is useless use of memory. The augmented array is shuffled so \n", - " # that randomisation is ensured when dataloaders iterate the dataset.\n" + " Image files are not manipulated as it would cause unnecessary overhead\n", + " \"\"\"\n", + " data_dir = Path(data_root)\n", + "\n", + " # Fetch the image names and labels dataset and load to a dataframe\n", + " data_df = pd.read_csv((data_dir / \"train-metadata.csv\"), index_col=0)\n", + "\n", + " # Get IDs and labels for dataset train/validation/test splitting\n", + " # The isic_id is unique\n", + " image_ids = data_df[\"isic_id\"]\n", + " labels = data_df[\"target\"]\n", + "\n", + " # Split into train, validation and test sets\n", + " # 80% of data to train, 10% to validate, 10% to test\n", + " # Split train and validation/test\n", + " train_ids, val_test_ids, train_labels, val_test_labels = train_test_split(\n", + " image_ids, labels, test_size=0.2, stratify=labels, random_state=SEED\n", + " )\n", + " # Split validation and test\n", + " val_ids, test_ids, val_labels, test_labels = train_test_split(\n", + " val_test_ids, val_test_labels, test_size=0.5, stratify=val_test_labels, random_state=SEED\n", + " )\n", + "\n", + " # Subset dataframe for train, validation and test\n", + " # The isic_id column will be used to fetch the images when dataloading\n", + " # The dataframe index is reset for ease of access at dataloading phase\n", + " train_samples = data_df[data_df[\"isic_id\"].isin(train_ids)].reset_index(drop=True)\n", + " val_samples = data_df[data_df[\"isic_id\"].isin(val_ids)].reset_index(drop=True)\n", + " test_samples = data_df[data_df[\"isic_id\"].isin(test_ids)].reset_index(drop=True)\n", + "\n", + " # Oversample the minority class in the training set\n", + " # There will be an equal amount of rows for each class\n", + " normal_samples_size = train_samples[train_samples[\"target\"]== 0].shape[0]\n", + " melanoma_sample = train_samples[train_samples[\"target\"]== 1]\n", + " oversample_sample = melanoma_sample.sample(n=normal_samples_size - melanoma_sample.shape[0], replace=True, random_state=SEED)\n", + "\n", + " # Concatenate the data and the oversaampled data into one dataframe\n", + " train_samples = pd.concat([train_samples, oversample_sample], ignore_index=True)\n", + " train_samples = train_samples.sample(frac=1).reset_index(drop=True)\n", + " # Logic: We duplicate some of the image references in the training data \n", + " # label dataframe. Since the images will be transformed when loaded, this \n", + " # will augment the melanoma samples. We only add duplicated rows as this \n", + " # array is what gets iterated on by the Dataloader. There is no need to \n", + " # duplicate the image, that is useless use of memory. The augmented array \n", + " # is shuffled so that randomisation is ensured when dataloaders iterate \n", + " # the dataset.\n", + "\n", + " return train_samples, val_samples, test_samples" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "ee90ac6d", "metadata": {}, "outputs": [], @@ -165,34 +178,38 @@ " \"\"\"\n", " Custom Dataset class for ISIC images and labels.\n", " \"\"\"\n", - " def __init__(self, root_dir, transform=None):\n", - " self.image_dir = Path(root_dir) / 'images'\n", - " #TODO: load the labels dataset\n", - " self.labels_df = None\n", - " self.transform = transform\n", - " # CHECK THE LABEL NAMES\n", + " def __init__(self, root_dir, items_df, transform:transforms.Compose=None):\n", + "\n", + " # get the image folder path\n", + " self.image_dir = (Path(root_dir) / 'image')\n", + " # get the labels dataframe\n", + " self.items_df = items_df\n", + " # Label names\n", " self.classes = ['normal', 'melanoma']\n", "\n", - " # Standard image transformation for pre-trained models\n", - " # ADD MORE TRANSFORMATIONS\n", - " self.transform = transforms.Compose([\n", - " transforms.ToPILImage(),\n", - " transforms.ToTensor(),\n", - " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", - " ])\n", + " # Standard image transformation to which we add supplied tranformations\n", + " self.transform = transforms.Compose(\n", + " (transform.transforms if transform else [])+\n", + " #[transforms.ToPILImage(),\n", + " [transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]\n", + " )\n", "\n", - " self.len = np.shape(self.labels_df) # ADD 0 OR 1\n", + " self.len = self.items_df.shape[0] \n", "\n", " def __len__(self):\n", " return self.len\n", " \n", " def __getitem__(self, idx):\n", "\n", - " # ADD POSITIONAL ARGUMENT\n", - " label = self.labels_df[idx, None]\n", - " image_name = self.labels_df[idx, None]\n", + " # Get image information from the dataframe\n", + " item = self.items_df.iloc[idx]\n", + " # Get image label\n", + " label = item[\"target\"]\n", + " # Get image\n", + " image_name = item[\"isic_id\"]\n", " image = Image.open(self.image_dir / (image_name + \".jpg\")).convert('RGB')\n", - "\n", + " # Transform image\n", " image = self.transform(image)\n", " \n", " return image, torch.tensor(label, dtype=torch.long)" @@ -200,17 +217,117 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "80fa4cd7", + "execution_count": 5, + "id": "79f2811b", "metadata": {}, "outputs": [], + "source": [ + "class TripletDataset(Dataset):\n", + " \"\"\"\n", + " Custom Dataset for generating (Anchor, Positive, Negative) triplets.\n", + " \"\"\"\n", + " def __init__(self, root_dir, items_df, transform=None):\n", + " #self.root_dir = root_dir\n", + " #self.transform = transform\n", + " \n", + " # get the image folder path\n", + " self.image_dir = (Path(root_dir) / 'image')\n", + " # get the labels dataframe\n", + " self.items_df = items_df\n", + " # Label names\n", + " self.classes = ['normal', 'melanoma']\n", + "\n", + " # Standard image transformation to which we add supplied tranformations\n", + " self.transform = transforms.Compose(\n", + " (transform.transforms if transform else [])+\n", + " #[transforms.ToPILImage(),\n", + " [transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]\n", + " )\n", + " \n", + " # Total number of unique images to iterate over\n", + " self.len = self.items_df.shape[0] \n", + "\n", + " def __len__(self):\n", + " return self.len\n", + "\n", + " def __getitem__(self, index):\n", + " # 1. Select Anchor (A)\n", + " #anchor_path, anchor_class = self.all_paths[index]\n", + "\n", + " # Get image information from the dataframe\n", + " anchor = self.items_df.iloc[index]\n", + " # Get image label\n", + " anchor_class = anchor[\"target\"]\n", + " # Get image\n", + " anchor_name = anchor[\"isic_id\"]\n", + " anchor_image = Image.open(self.image_dir / (anchor_name + \".jpg\")).convert('RGB')\n", + " # Transform image\n", + " anchor_image = self.transform(anchor_image)\n", + " \n", + " # 2. Select Positive (P)\n", + " # Select an image from the same class as the anchor, but not the anchor itself\n", + " try:\n", + " positive = self.items_df[(self.items_df[\"isic_id\"]!=anchor_name) & (self.items_df[\"target\"]==anchor_class)].sample()\n", + " except:\n", + " # Handle edge case where only one image exists in the class (should not happen in real ISIC)\n", + " positive = anchor\n", + "\n", + " # Get image\n", + " positive_name = positive[\"isic_id\"].item()\n", + " positive_image = Image.open(self.image_dir / (positive_name + \".jpg\")).convert('RGB')\n", + " # Transform image\n", + " positive_image = self.transform(positive_image)\n", + "\n", + " # 3. Select Negative (N)\n", + " # Select a class different from the anchor class (binary case is simple)\n", + " negative_class = 1 - anchor_class\n", + " # Select a negative sample\n", + " negative = self.items_df[self.items_df[\"target\"]==negative_class].sample()\n", + " # Get image\n", + " negative_name = negative[\"isic_id\"].item()\n", + " negative_image = Image.open(self.image_dir / (negative_name + \".jpg\")).convert('RGB')\n", + " # Transform image\n", + " negative_image = self.transform(negative_image)\n", + "\n", + " # Return triplet and the anchor's original label for verification/testing\n", + " return anchor_image, positive_image, negative_image, anchor_class" + ] + }, + { + "cell_type": "markdown", + "id": "839e4757", + "metadata": {}, + "source": [ + "class ClassificationNet(nn.Module):\n", + " \"\"\"\n", + " A simple linear head trained on top of the fixed embeddings \n", + " for the final binary classification (Melanoma vs. Normal).\n", + " \"\"\"\n", + " def __init__(self, embedding_dim):\n", + " super(ClassificationNet, self).__init__()\n", + " self.classifier = nn.Sequential(\n", + " nn.Linear(embedding_dim, 64),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.3),\n", + " nn.Linear(64, 2) # Two classes: 0 (Normal) and 1 (Melanoma)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " return self.classifier(x)" + ] + }, + { + "cell_type": "markdown", + "id": "80fa4cd7", + "metadata": {}, "source": [ "class EmbeddingNet(nn.Module):\n", " \"\"\"Simple non-pretrained CNN to generate image embeddings.\"\"\"\n", - " def __init__(self, out_dim=EMBEDDING_DIM):\n", + " def __init__(self, image_size=IMAGE_SIZE, out_dim=EMBEDDING_DIM):\n", " super(EmbeddingNet, self).__init__()\n", " \n", - " # Output size after Conv1 (128->64) -> Conv2 (64->32) -> Conv3 (32->16)\n", + " # Output size after Conv1 (256->128) -> Conv2 (128->64) -> Conv3 (64->32) -> Conv4 (32->16)\n", " # Layer 1: Conv -> ReLU -> Pool\n", " self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)\n", " self.bn1 = nn.BatchNorm2d(32)\n", @@ -225,19 +342,28 @@ " self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n", " self.bn3 = nn.BatchNorm2d(128)\n", " self.pool3 = nn.MaxPool2d(2, 2)\n", + "\n", + " # Layer 4: Conv -> ReLU -> Pool\n", + " self.conv4 = nn.Conv2d(128, 256, kernel_size=3, padding=1)\n", + " self.bn4 = nn.BatchNorm2d(256)\n", + " self.pool4 = nn.MaxPool2d(2, 2)\n", " \n", " # Calculate the size before the first linear layer\n", - " # 128 -> 64 -> 32 -> 16. The output size is 16x16 with 128 channels.\n", - " self.fc_input_size = 128 * (IMAGE_SIZE // 8) * (IMAGE_SIZE // 8) # 128 * 16 * 16 = 32768\n", + " # 256 -> 128 -> 64 -> 32 -> 16. The output size is 16x16 with 256 channels.\n", + " self.fc_input_size = 256 * (image_size // 16) * (image_size // 16) # 256 * 16 * 16 = 65536\n", "\n", " # Fully Connected Layer to produce the embedding\n", " self.fc1 = nn.Linear(self.fc_input_size, 512)\n", " self.fc_out = nn.Linear(512, out_dim)\n", "\n", + " # classification head\n", + " self.classifier = ClassificationNet(out_dim)\n", + "\n", " def forward(self, x):\n", " x = self.pool1(nn.functional.relu(self.bn1(self.conv1(x))))\n", " x = self.pool2(nn.functional.relu(self.bn2(self.conv2(x))))\n", " x = self.pool3(nn.functional.relu(self.bn3(self.conv3(x))))\n", + " x = self.pool4(nn.functional.relu(self.bn4(self.conv4(x))))\n", " \n", " # Flatten the feature map\n", " x = x.view(x.size(0), -1) \n", @@ -248,15 +374,97 @@ " \n", " # L2-normalize the embedding vector\n", " x = nn.functional.normalize(x, p=2, dim=1)\n", - " return x" + " return x\n", + " \n", + " def classify(self, x):\n", + " return self.classifier(x)" ] }, { "cell_type": "code", "execution_count": null, - "id": "5932bab8", + "id": "d324fd98", + "metadata": {}, + "outputs": [], + "source": [ + "class EmbeddingNet(nn.Module):\n", + " \"\"\"Simple non-pretrained CNN to generate image embeddings.\"\"\"\n", + " def __init__(self, image_size=IMAGE_SIZE, out_dim=EMBEDDING_DIM):\n", + " super(EmbeddingNet, self).__init__()\n", + " \n", + " # load a ResNet model\n", + " resnet = models.resnet50()\n", + "\n", + " self.extractor = nn.Sequential(*list(resnet.children())[:-1])\n", + "\n", + " self.fc_out = nn.Sequential(\n", + " nn.Linear(2048, 512),\n", + " nn.ReLU(inplace=True),\n", + " nn.Dropout(0.5),\n", + " nn.Linear(512, 256),\n", + " nn.ReLU(inplace=True),\n", + " nn.Dropout(0.5),\n", + " nn.Linear(256, out_dim)\n", + " )\n", + " \n", + " # Calculate the size before the first linear layer\n", + " # 256 -> 128 -> 64 -> 32 -> 16. The output size is 16x16 with 256 channels.\n", + " #self.fc_input_size = 256 * (image_size // 16) * (image_size // 16) # 256 * 16 * 16 = 65536\n", + "\n", + " # Fully Connected Layer to produce the embedding\n", + " #self.fc1 = nn.Linear(self.fc_input_size, 512)\n", + " #self.fc_out = nn.Linear(512, out_dim)\n", + "\n", + " # classification head\n", + " self.classifier = nn.Linear(out_dim, 2)\n", + "\n", + " def forward(self, x):\n", + " # extract features\n", + " x = self.extractor(x)\n", + " # Flatten the feature map\n", + " x = x.view(x.size(0), -1) \n", + " # Final embedding output\n", + " x = self.fc_out(x)\n", + " \n", + " # L2-normalize the embedding vector\n", + " #x = nn.functional.normalize(x, p=2, dim=1)\n", + " return x\n", + " \n", + " def classify(self, x):\n", + " return self.classifier(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a5701bdd", "metadata": {}, "outputs": [], + "source": [ + "class TripletLoss(nn.Module):\n", + " \"\"\"\n", + " Triplet loss function based on the distance between embeddings.\n", + " L(A, P, N) = max(0, ||f(A) - f(P)||^2 - ||f(A) - f(N)||^2 + margin)\n", + " \"\"\"\n", + " def __init__(self, margin=1.0):\n", + " super(TripletLoss, self).__init__()\n", + " self.margin = margin\n", + " self.p = 2 # L2 distance\n", + "\n", + " def forward(self, anchor, positive, negative):\n", + " # Calculate squared L2 distance\n", + " d_pos = nn.functional.pairwise_distance(anchor, positive, p=self.p)\n", + " d_neg = nn.functional.pairwise_distance(anchor, negative, p=self.p)\n", + " \n", + " # Triplet loss formula\n", + " loss = torch.relu(d_pos - d_neg + self.margin).mean()\n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "id": "5932bab8", + "metadata": {}, "source": [ "def get_pairwise_distances(embeddings):\n", " \"\"\"Computes the squared Euclidean distance matrix.\"\"\"\n", @@ -264,7 +472,64 @@ " square_norm = torch.diag(dot_product)\n", " distances = square_norm.unsqueeze(0) - 2.0 * dot_product + square_norm.unsqueeze(1)\n", " distances[distances < 0] = 0 # Ensure non-negative distances\n", - " return distances.sqrt()\n", + " #return torch.sqrt(distances + 1e-8)#distances.sqrt()\n", + " mask = (distances == 0.0).float()\n", + "\n", + " # use this mask to set indices with a value of 0 to eps\n", + " distances += mask * 1e-8\n", + "\n", + " # now it is safe to get the square root\n", + " distances = torch.sqrt(distances)\n", + "\n", + " # undo the trick for numerical stability\n", + " distances *= (1.0 - mask)\n", + "\n", + " return distances\n", + "\n", + "def euclidean_distance_matrix(x):\n", + " \"\"\"Efficient computation of Euclidean distance matrix\n", + " Args:\n", + " x: Input tensor of shape (batch_size, embedding_dim)\n", + " \n", + " Returns:\n", + " Distance matrix of shape (batch_size, batch_size)\n", + " \"\"\"\n", + " # step 1 - compute the dot product\n", + "\n", + " # shape: (batch_size, batch_size)\n", + " dot_product = torch.mm(x, x.t())\n", + "\n", + " # step 2 - extract the squared Euclidean norm from the diagonal\n", + "\n", + " # shape: (batch_size,)\n", + " squared_norm = torch.diag(dot_product)\n", + "\n", + " # step 3 - compute squared Euclidean distances\n", + "\n", + " # shape: (batch_size, batch_size)\n", + " distance_matrix = squared_norm.unsqueeze(0) - 2 * dot_product + squared_norm.unsqueeze(1)\n", + "\n", + " # get rid of negative distances due to numerical instabilities\n", + " distance_matrix = F.relu(distance_matrix)\n", + "\n", + " # step 4 - compute the non-squared distances\n", + " \n", + " # handle numerical stability\n", + " # derivative of the square root operation applied to 0 is infinite\n", + " # we need to handle by setting any 0 to eps\n", + " return torch.sqrt(distance_matrix + 1e-8)\n", + " mask = (distance_matrix == 0.0).float()\n", + "\n", + " # use this mask to set indices with a value of 0 to eps\n", + " distance_matrix += mask * 1e-8\n", + "\n", + " # now it is safe to get the square root\n", + " distance_matrix = torch.sqrt(distance_matrix)\n", + "\n", + " # undo the trick for numerical stability\n", + " distance_matrix *= (1.0 - mask)\n", + "\n", + " return distance_matrix\n", "\n", "\n", "def get_triplets(labels, distances):\n", @@ -301,6 +566,91 @@ "\n", " return hardest_positive_dist, hardest_negative_dist\n", "\n", + "def get_triplet_mask(labels):\n", + " \"\"\"compute a mask for valid triplets\n", + " Args:\n", + " labels: Batch of integer labels. shape: (batch_size,)\n", + " Returns:\n", + " Mask tensor to indicate which triplets are actually valid. Shape: (batch_size, batch_size, batch_size)\n", + " A triplet is valid if:\n", + " `labels[i] == labels[j] and labels[i] != labels[k]`\n", + " and `i`, `j`, `k` are different.\n", + " \"\"\"\n", + " # step 1 - get a mask for distinct indices\n", + "\n", + " # shape: (batch_size, batch_size)\n", + " indices_equal = torch.eye(labels.size()[0], dtype=torch.bool, device=labels.device)\n", + " indices_not_equal = torch.logical_not(indices_equal)\n", + " # shape: (batch_size, batch_size, 1)\n", + " i_not_equal_j = indices_not_equal.unsqueeze(2)\n", + " # shape: (batch_size, 1, batch_size)\n", + " i_not_equal_k = indices_not_equal.unsqueeze(1)\n", + " # shape: (1, batch_size, batch_size)\n", + " j_not_equal_k = indices_not_equal.unsqueeze(0)\n", + " # Shape: (batch_size, batch_size, batch_size)\n", + " distinct_indices = torch.logical_and(torch.logical_and(i_not_equal_j, i_not_equal_k), j_not_equal_k)\n", + "\n", + " # step 2 - get a mask for valid anchor-positive-negative triplets\n", + "\n", + " # shape: (batch_size, batch_size)\n", + " labels_equal = labels.unsqueeze(0) == labels.unsqueeze(1)\n", + " # shape: (batch_size, batch_size, 1)\n", + " i_equal_j = labels_equal.unsqueeze(2)\n", + " # shape: (batch_size, 1, batch_size)\n", + " i_equal_k = labels_equal.unsqueeze(1)\n", + " # shape: (batch_size, batch_size, batch_size)\n", + " valid_indices = torch.logical_and(i_equal_j, torch.logical_not(i_equal_k))\n", + "\n", + " # step 3 - combine two masks\n", + " mask = torch.logical_and(distinct_indices, valid_indices)\n", + "\n", + " return mask\n", + "\n", + "class BatchAllTtripletLoss(nn.Module):\n", + " \"\"\"Uses all valid triplets to compute Triplet loss\n", + " Args:\n", + " margin: Margin value in the Triplet Loss equation\n", + " \"\"\"\n", + " def __init__(self, margin=1.):\n", + " super().__init__()\n", + " self.margin = margin\n", + " \n", + " def forward(self, embeddings, labels):\n", + " \"\"\"computes loss value.\n", + " Args:\n", + " embeddings: Batch of embeddings, e.g., output of the encoder. shape: (batch_size, embedding_dim)\n", + " labels: Batch of integer labels associated with embeddings. shape: (batch_size,)\n", + " Returns:\n", + " Scalar loss value.\n", + " \"\"\"\n", + " # step 1 - get distance matrix\n", + " # shape: (batch_size, batch_size)\n", + " distance_matrix = euclidean_distance_matrix(embeddings)\n", + "\n", + " # step 2 - compute loss values for all triplets by applying broadcasting to distance matrix\n", + "\n", + " # shape: (batch_size, batch_size, 1)\n", + " anchor_positive_dists = distance_matrix.unsqueeze(2)\n", + " # shape: (batch_size, 1, batch_size)\n", + " anchor_negative_dists = distance_matrix.unsqueeze(1)\n", + " # get loss values for all possible n^3 triplets\n", + " # shape: (batch_size, batch_size, batch_size)\n", + " triplet_loss = anchor_positive_dists - anchor_negative_dists + self.margin\n", + "\n", + " # step 3 - filter out invalid or easy triplets by setting their loss values to 0\n", + "\n", + " # shape: (batch_size, batch_size, batch_size)\n", + " mask = get_triplet_mask(labels)\n", + " triplet_loss *= mask\n", + " # easy triplets have negative loss values\n", + " triplet_loss = F.relu(triplet_loss)\n", + "\n", + " # step 4 - compute scalar loss value by averaging positive losses\n", + " num_positive_losses = (triplet_loss > 1e-8).float().sum()\n", + " triplet_loss = triplet_loss.sum() / (num_positive_losses + 1e-8)\n", + "\n", + " return triplet_loss\n", + " \n", "\n", "class TripletMarginLoss(nn.Module):\n", " \"\"\"\n", @@ -328,11 +678,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "id": "cffbcedc", "metadata": {}, - "outputs": [], "source": [ "def train_embedding_net(model, train_loader, criterion, optimizer, epochs, device):\n", " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", @@ -367,36 +715,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "2d0fba17", - "metadata": {}, - "outputs": [], - "source": [ - "class ClassificationNet(nn.Module):\n", - " \"\"\"\n", - " A simple linear head trained on top of the fixed embeddings \n", - " for the final binary classification (Melanoma vs. Normal).\n", - " \"\"\"\n", - " def __init__(self, embedding_dim):\n", - " super(ClassificationNet, self).__init__()\n", - " self.classifier = nn.Sequential(\n", - " nn.Linear(embedding_dim, 64),\n", - " nn.ReLU(),\n", - " nn.Dropout(0.3),\n", - " nn.Linear(64, 2) # Two classes: 0 (Normal) and 1 (Melanoma)\n", - " )\n", - "\n", - " def forward(self, x):\n", - " return self.classifier(x)" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "id": "bcb8420a", "metadata": {}, - "outputs": [], "source": [ "def train_classifier_head(embedding_net, classifier_head, train_loader, criterion, optimizer, epochs, device):\n", " \"\"\"Trains the Classification Head while freezing the Embedding Net.\"\"\"\n", @@ -438,15 +759,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "b8459f00", "metadata": {}, "outputs": [], "source": [ - "def evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, evaluation_loader, device):\n", + "def evaluate_model(embedding_net, embedding_crit, classifier_crit, evaluation_loader, device):\n", " \"\"\"Evaluates the final model on the test set.\"\"\"\n", " embedding_net.eval()\n", - " classifier_net.eval()\n", " \n", " all_labels = []\n", " all_predictions = []\n", @@ -460,35 +780,35 @@ " images, labels = images.to(device), labels.to(device)\n", " \n", " embeddings = embedding_net(images)\n", - " outputs = classifier_net(embeddings)\n", + " #outputs = embedding_net.classify(embeddings)\n", "\n", " emb_loss = embedding_crit(embeddings, labels)\n", " emb_running_loss += emb_loss.item() * len(images)\n", "\n", - " clas_loss = classifier_crit(outputs, labels)\n", - " clas_running_loss += clas_loss.item() * len(images)\n", + " #clas_loss = classifier_crit(outputs, labels)\n", + " #clas_running_loss += clas_loss.item() * len(images)\n", " \n", " # Predictions and Probabilities\n", - " _, preds = torch.max(outputs, 1)\n", - " probs = torch.softmax(outputs, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", + " #_, preds = torch.max(outputs, 1)\n", + " #probs = torch.softmax(outputs, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", "\n", - " all_labels.extend(labels.cpu().numpy())\n", - " all_predictions.extend(preds.cpu().numpy())\n", - " all_probs.extend(probs.cpu().numpy())\n", + " #all_labels.extend(labels.cpu().numpy())\n", + " #all_predictions.extend(preds.cpu().numpy())\n", + " #all_probs.extend(probs.cpu().numpy())\n", "\n", " total_samples += len(images)\n", "\n", " emb_epoch_loss = emb_running_loss / total_samples\n", - " clas_epoch_loss = clas_running_loss / total_samples\n", - " acc = accuracy_score(all_labels, all_predictions)\n", - " try:\n", + " #clas_epoch_loss = clas_running_loss / total_samples\n", + " #acc = accuracy_score(all_labels, all_predictions)\n", + " #try:\n", " # AUC is critical for imbalanced data like ISIC\n", - " auc = roc_auc_score(all_labels, all_probs)\n", - " except ValueError:\n", + " #auc = roc_auc_score(all_labels, all_probs)\n", + " #except ValueError:\n", " # Handle cases where only one class is present (unlikely with stratify, but possible with small batches)\n", - " auc = 0.5 \n", + " #auc = 0.5 \n", "\n", - " return emb_epoch_loss, clas_epoch_loss, acc, auc\n", + " return emb_epoch_loss#, clas_epoch_loss, acc, auc\n", " #print(\"\\n--- Final Test Set Results ---\")\n", " #print(f\"Overall Classification Accuracy: {overall_acc:.4f}\")\n", " #print(f\"ROC AUC Score (Melanoma): {overall_auc:.4f}\")\n", @@ -504,7 +824,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "8d9e9b5c", "metadata": {}, "outputs": [], @@ -521,7 +841,7 @@ " \n", " plt.figure(figsize=(15, 15))\n", "\n", - " plt.subplot(2, 1, 1)\n", + " plt.subplot(2, 2, 1)\n", " plt.plot(range(epochs), emb_train_loss_log, label='Train Loss', color='#F05039')\n", " plt.plot(range(epochs), emb_val_loss_log, label='Validation Loss', color='#3D65A5')\n", " plt.title('Embedding Loss over Epochs')\n", @@ -529,7 +849,7 @@ " plt.ylabel('Loss')\n", " plt.legend()\n", "\n", - " plt.subplot(2, 1, 2)\n", + " plt.subplot(2, 2, 2)\n", " plt.plot(range(epochs), clas_train_loss_log, label='Train Loss', color='#F05039')\n", " plt.plot(range(epochs), clas_val_loss_log, label='Validation Loss', color='#3D65A5')\n", " plt.title('Classification Loss over Epochs')\n", @@ -537,7 +857,7 @@ " plt.ylabel('Loss')\n", " plt.legend()\n", "\n", - " plt.subplot(2, 1, 3)\n", + " plt.subplot(2, 2, 3)\n", " plt.plot(range(epochs), train_accuracy_log, label='Train Accuracy', color='#F05039')\n", " plt.plot(range(epochs), val_accuracy_log, label='Validation Accuracy', color='#3D65A5')\n", " plt.title('Accuracy over Epochs')\n", @@ -545,7 +865,7 @@ " plt.ylabel('Accuracy')\n", " plt.legend()\n", "\n", - " plt.subplot(2, 1, 3)\n", + " plt.subplot(2, 2, 4)\n", " plt.plot(range(epochs), val_ROC_AUC_log, label='ROC AUC', color='#3D65A5')\n", " plt.title('Validation ROC AUC over Epochs')\n", " plt.xlabel('Epochs')\n", @@ -559,11 +879,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "id": "7570a5b9", "metadata": {}, - "outputs": [], "source": [ "def train_nets(\n", " embedding_net, classifier_net, \n", @@ -601,9 +919,9 @@ "\n", " for i, (images, labels) in enumerate(train_loader):\n", " images, labels = images.to(device), labels.to(device)\n", + " print(i)\n", "\n", " # ---- Embedding model training ----\n", - " \n", " embedding_opt.zero_grad()\n", " \n", " # Generate embeddings\n", @@ -621,12 +939,12 @@ " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {emb_loss.item():.4f}')\n", "\n", " # ---- Classification model training ----\n", - "\n", " classifier_opt.zero_grad()\n", " \n", " # Classify\n", " outputs = classifier_net(embeddings)\n", " clas_loss = classifier_crit(outputs, labels)\n", + " print(clas_loss)\n", " \n", " clas_loss.backward()\n", " classifier_opt.step()\n", @@ -673,8 +991,8 @@ " best_val_ROC_AUC = epoch_val_ROC_AUC\n", " # Save model checkpoint\n", " print(\"Saving best model...\")\n", - " torch.save(embedding_net.state_dict(), 'best_embedding_model.pth')\n", - " torch.save(classifier_net.state_dict(), 'best_classifier_model.pth')\n", + " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", + " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", "\n", "\n", " print(\"Network training complete.\")\n", @@ -692,60 +1010,2382 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "407883a9", + "cell_type": "markdown", + "id": "1cdc60c0", "metadata": {}, - "outputs": [], "source": [ + "def train_nets(\n", + " embedding_net, classifier_net, \n", + " train_loader, val_loader, \n", + " embedding_crit, classifier_crit, \n", + " embedding_opt, classifier_opt, \n", + " scheduler,\n", + " epochs, \n", + " device):\n", + " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", + " \n", + " print(\"\\n--- Training Networks ---\")\n", + "\n", + " # metric logging intialisation\n", + " best_val_ROC_AUC = -1.0\n", + " emb_train_loss_log = []\n", + " clas_train_loss_log = []\n", + " train_accuracy_log = []\n", + " emb_val_loss_log = []\n", + " clas_val_loss_log = []\n", + " val_accuracy_log = []\n", + " val_ROC_AUC_log = []\n", + " \n", + " for epoch in range(1, epochs + 1):\n", + " embedding_net.train()\n", + " classifier_net.train()\n", + " emb_running_loss = 0.0\n", + " clas_running_loss = 0.0\n", + " correct_predictions = 0\n", + " total_samples = 0\n", "\n", - "train_dataset = SkinDataset((data_dir / 'train'), transform=None)\n", - "val_dataset = SkinDataset((data_dir / 'val'), transform=None)\n", + " print(f\"\\n==== Training Epoch {epoch} ====\")\n", "\n", - "# Use standard DataLoader; Triplet mining is handled in the custom loss\n", - "train_loader = DataLoader(train_dataset, batch_size=TRAIN_BATCH_SIZE, shuffle=True, drop_last=True, num_workers=4)\n", - "val_loader = DataLoader(val_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=8)\n", + " # --- Training phase ----\n", "\n", - "# Model Setup\n", + " for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + " #print(i)\n", "\n", - "# Embedding Net with Triplet Loss\n", - "embedding_net = EmbeddingNet(EMBEDDING_DIM).to(device)\n", - "triplet_criterion = TripletMarginLoss(margin=MARGIN)\n", - "embedding_optimizer = optim.Adam(embedding_net.parameters(), lr=LEARNING_RATE)\n", - "embedding_scheduler = optim.lr_scheduler.ReduceLROnPlateau(embedding_optimizer, mode='max', factor=0.5, patience=5)\n", + " # ---- Embedding model training ----\n", + " \n", + " \n", + " # Generate embeddings\n", + " embeddings = embedding_net(images)\n", + " \n", + " # Calculate Triplet Loss using Batch-Hard mining\n", + " emb_loss = embedding_crit(embeddings, labels)\n", + " \n", + " # ---- Classification model training ----\n", + " \n", + " \n", + " # Classify\n", + " outputs = classifier_net(embeddings)\n", + " clas_loss = classifier_crit(outputs, labels)\n", "\n", - "# Classification Head with Cross-Entropy Loss\n", - "classifier_head = ClassificationNet(EMBEDDING_DIM).to(device)\n", - "classification_criterion = nn.CrossEntropyLoss().to(device)\n", - "classifier_optimizer = optim.Adam(classifier_head.parameters(), lr=LEARNING_RATE)# * 5) # Faster learning rate for small head\n", + " # Statistics\n", + " emb_running_loss += emb_loss.item() * len(images)\n", + " clas_running_loss += clas_loss.item() * len(images)\n", + " _, preds = torch.max(outputs, 1)\n", + " correct_predictions += torch.sum(preds == labels.data).item()\n", + " total_samples += len(images)\n", "\n", - "train_nets(\n", - " embedding_net, classifier_head, \n", - " train_loader, val_loader, \n", - " triplet_criterion, classification_criterion, \n", - " embedding_optimizer, classifier_optimizer, \n", - " embedding_scheduler,\n", - " NUM_EPOCHS, \n", - " device)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d4f83545", - "metadata": {}, - "outputs": [], - "source": [ - "# Evaluation\n", - "test_dataset = SkinDataset((data_dir / 'test'), transform=None)\n", - "val_loader = DataLoader(test_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=0)\n", - "evaluate_model(embedding_net, classifier_head, val_loader, device)" - ] - } - ], - "metadata": { + " if (i + 1) % 50 == 0:\n", + " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_loss.item()):.4f}, Classification training loss: {(clas_loss.item()):.4f}')\n", + " #print(clas_loss)\n", + "\n", + " total_loss = emb_loss + clas_loss\n", + "\n", + " embedding_opt.zero_grad()\n", + " classifier_opt.zero_grad()\n", + " total_loss.backward()\n", + " embedding_opt.step()\n", + " classifier_opt.step()\n", + "\n", + " # embedding training epoch loss\n", + " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", + " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", + "\n", + " # classification training epoch loss\n", + " clas_epoch_loss = clas_running_loss / total_samples\n", + " epoch_acc = correct_predictions / total_samples\n", + " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", + " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", + "\n", + " # ---- Evaluation phase ----\n", + "\n", + " print(\"--- Validation phase ---\")\n", + " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", + " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", + " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", + " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", + " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", + "\n", + " # metric logging for plotting\n", + " emb_train_loss_log.append(emb_epoch_loss)\n", + " clas_train_loss_log.append(clas_epoch_loss)\n", + " train_accuracy_log.append(epoch_acc)\n", + " emb_val_loss_log.append(val_emb_loss)\n", + " clas_val_loss_log.append(val_clas_loss)\n", + " val_accuracy_log.append(epoch_val_accuracy)\n", + " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", + "\n", + " scheduler.step(epoch_val_ROC_AUC)\n", + "\n", + " # save best model based on ROC AUC\n", + " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", + " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", + " best_val_ROC_AUC = epoch_val_ROC_AUC\n", + " # Save model checkpoint\n", + " print(\"Saving best model...\")\n", + " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", + " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", + "\n", + "\n", + " print(\"Network training complete.\")\n", + "\n", + " # Graphical display of metric logs\n", + " plot_logs(\n", + " emb_train_loss_log, \n", + " clas_train_loss_log,\n", + " train_accuracy_log,\n", + " emb_val_loss_log,\n", + " clas_val_loss_log,\n", + " val_accuracy_log,\n", + " val_ROC_AUC_log,\n", + " epochs)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e955f931", + "metadata": {}, + "outputs": [], + "source": [ + "def train_nets(\n", + " train_loader, val_loader,\n", + " embedding_net, embedding_opt, \n", + " embedding_crit, classifier_crit,\n", + " scheduler,\n", + " epochs, \n", + " device):\n", + " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", + " \n", + " print(\"\\n--- Training Networks ---\")\n", + "\n", + " # metric logging intialisation\n", + " best_val_ROC_AUC = -1.0\n", + " emb_train_loss_log = []\n", + " clas_train_loss_log = []\n", + " train_accuracy_log = []\n", + " emb_val_loss_log = []\n", + " clas_val_loss_log = []\n", + " val_accuracy_log = []\n", + " val_ROC_AUC_log = []\n", + " \n", + " for epoch in range(1, epochs + 1):\n", + " embedding_net.train()\n", + " #classifier_net.train()\n", + " emb_running_loss = 0.0\n", + " clas_running_loss = 0.0\n", + " correct_predictions = 0\n", + " total_samples = 0\n", + "\n", + " print(f\"\\n==== Training Epoch {epoch} ====\")\n", + " #with torch.autograd.detect_anomaly():\n", + " # --- Training phase ----\n", + "\n", + " for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + "\n", + " # ---- Embedding model training ----\n", + " embedding_opt.zero_grad()\n", + " \n", + " # Generate embeddings\n", + " embeddings = embedding_net(images)\n", + " \n", + " # Calculate Triplet Loss using Batch-Hard mining\n", + " emb_loss = embedding_crit(embeddings, labels)\n", + " \n", + " # ---- Classification model training ----\n", + " \n", + " \n", + " # Classify\n", + " #outputs = embedding_net.classify(embeddings)\n", + " #clas_loss = classifier_crit(outputs, labels)\n", + "\n", + " # Statistics\n", + " emb_running_loss += emb_loss.item() * len(images)\n", + " #clas_running_loss += clas_loss.item() * len(images)\n", + " #_, preds = torch.max(outputs, 1)\n", + " #correct_predictions += torch.sum(preds == labels.data).item()\n", + " total_samples += len(images)\n", + "\n", + " #print(emb_loss.item(), emb_running_loss, clas_loss.item(), clas_running_loss)\n", + " if (i + 1) % 200 == 0:\n", + " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_loss.item()):.4f}')#, Classification training loss: {(clas_loss.item()):.4f}')\n", + " scheduler.step()\n", + " #print(clas_loss)\n", + "\n", + " total_loss = emb_loss #+ clas_loss\n", + " \n", + " total_loss.backward()\n", + " embedding_opt.step()\n", + "\n", + " # embedding training epoch loss\n", + " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", + " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", + "\n", + " # classification training epoch loss\n", + " #clas_epoch_loss = clas_running_loss / total_samples\n", + " #epoch_acc = correct_predictions / total_samples\n", + " #print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", + " #print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", + "\n", + " # ---- Evaluation phase ----\n", + "\n", + " print(\"--- Validation phase ---\")\n", + " val_emb_loss = evaluate_model(embedding_net, embedding_crit, classifier_crit, val_loader, device)\n", + " #val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, embedding_crit, classifier_crit, val_loader, device)\n", + " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", + " #print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", + " #print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", + " #print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", + "\n", + " # metric logging for plotting\n", + " emb_train_loss_log.append(emb_epoch_loss)\n", + " #clas_train_loss_log.append(clas_epoch_loss)\n", + " #train_accuracy_log.append(epoch_acc)\n", + " emb_val_loss_log.append(val_emb_loss)\n", + " #clas_val_loss_log.append(val_clas_loss)\n", + " #val_accuracy_log.append(epoch_val_accuracy)\n", + " #val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", + "\n", + " #scheduler.step(emb_epoch_loss)\n", + "\n", + " # save best model based on ROC AUC\n", + " #if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", + " # print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", + " # best_val_ROC_AUC = epoch_val_ROC_AUC\n", + " # Save model checkpoint\n", + " # print(\"Saving best model...\")\n", + " # torch.save(embedding_net.state_dict(), (Path(DATA_ROOT) / 'best_embedding_model.pth'))\n", + "\n", + "\n", + " print(\"Network training complete.\")\n", + "\n", + " # Graphical display of metric logs\n", + " plot_logs(\n", + " emb_train_loss_log, \n", + " clas_train_loss_log,\n", + " train_accuracy_log,\n", + " emb_val_loss_log,\n", + " clas_val_loss_log,\n", + " val_accuracy_log,\n", + " val_ROC_AUC_log,\n", + " epochs)\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "03dd5659", + "metadata": {}, + "source": [ + "def train_nets(\n", + " embedding_net, classifier_net, \n", + " train_loader, val_loader, \n", + " embedding_crit, classifier_crit, \n", + " embedding_opt, classifier_opt, \n", + " scheduler,\n", + " epochs, \n", + " device):\n", + " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", + " \n", + " print(\"\\n--- Training Networks ---\")\n", + "\n", + " # metric logging intialisation\n", + " best_val_ROC_AUC = -1.0\n", + " emb_train_loss_log = []\n", + " clas_train_loss_log = []\n", + " train_accuracy_log = []\n", + " emb_val_loss_log = []\n", + " clas_val_loss_log = []\n", + " val_accuracy_log = []\n", + " val_ROC_AUC_log = []\n", + " \n", + " for epoch in range(1, epochs + 1):\n", + " embedding_net.train()\n", + " classifier_net.train()\n", + " emb_running_loss = 0.0\n", + " clas_running_loss = 0.0\n", + " correct_predictions = 0\n", + " total_samples = 0\n", + "\n", + " print(f\"\\n==== Training Epoch {epoch} ====\")\n", + "\n", + " # --- Training phase ----\n", + "\n", + " for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + " print(i)\n", + "\n", + " # ---- Embedding model training ----\n", + " \n", + " embedding_opt.zero_grad()\n", + " classifier_opt.zero_grad()\n", + " \n", + " # Generate embeddings\n", + " embeddings = embedding_net(images)\n", + " \n", + " # Calculate Triplet Loss using Batch-Hard mining\n", + " emb_loss = embedding_crit(embeddings, labels).detach()\n", + " \n", + " \n", + " \n", + " emb_running_loss += emb_loss.item() * len(images)\n", + " \n", + " \n", + "\n", + " # ---- Classification model training ----\n", + "\n", + " \n", + " \n", + " # Classify\n", + " outputs = classifier_net(embeddings)\n", + " clas_loss = classifier_crit(outputs, labels)\n", + "\n", + " if (i + 1) % 50 == 0:\n", + " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {emb_loss.item():.4f}, Classification training loss: {clas_loss.item():.4f}')\n", + " #print(clas_loss)\n", + " \n", + " emb_loss.backward()\n", + " embedding_opt.step()\n", + " embedding_opt.zero_grad()\n", + " clas_loss.backward()\n", + " classifier_opt.step()\n", + " \n", + " # Statistics\n", + " clas_running_loss += clas_loss.item() * len(images)\n", + " _, preds = torch.max(outputs, 1)\n", + " correct_predictions += torch.sum(preds == labels.data).item()\n", + " total_samples += len(images)\n", + "\n", + " # embedding training epoch loss\n", + " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", + " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", + "\n", + " # classification training epoch loss\n", + " clas_epoch_loss = clas_running_loss / total_samples\n", + " epoch_acc = correct_predictions / total_samples\n", + " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", + " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", + "\n", + " # ---- Evaluation phase ----\n", + "\n", + " print(\"--- Validation phase ---\")\n", + " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", + " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", + " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", + " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", + " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", + "\n", + " # metric logging for plotting\n", + " emb_train_loss_log.append(emb_epoch_loss)\n", + " clas_train_loss_log.append(clas_epoch_loss)\n", + " train_accuracy_log.append(epoch_acc)\n", + " emb_val_loss_log.append(val_emb_loss)\n", + " clas_val_loss_log.append(val_clas_loss)\n", + " val_accuracy_log.append(epoch_val_accuracy)\n", + " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", + "\n", + " scheduler.step(epoch_val_ROC_AUC)\n", + "\n", + " # save best model based on ROC AUC\n", + " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", + " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", + " best_val_ROC_AUC = epoch_val_ROC_AUC\n", + " # Save model checkpoint\n", + " print(\"Saving best model...\")\n", + " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", + " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", + "\n", + "\n", + " print(\"Network training complete.\")\n", + "\n", + " # Graphical display of metric logs\n", + " plot_logs(\n", + " emb_train_loss_log, \n", + " clas_train_loss_log,\n", + " train_accuracy_log,\n", + " emb_val_loss_log,\n", + " clas_val_loss_log,\n", + " val_accuracy_log,\n", + " val_ROC_AUC_log,\n", + " epochs)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "407883a9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Training Networks ---\n", + "\n", + "==== Training Epoch 1 ====\n", + "Epoch 1/7, Batch 200/1627, Embedding training loss: 1.1077\n", + "Epoch 1/7, Batch 400/1627, Embedding training loss: 0.9941\n", + "Epoch 1/7, Batch 600/1627, Embedding training loss: 0.9646\n", + "Epoch 1/7, Batch 800/1627, Embedding training loss: 1.0336\n", + "Epoch 1/7, Batch 1000/1627, Embedding training loss: 1.0110\n", + "Epoch 1/7, Batch 1200/1627, Embedding training loss: 1.0264\n", + "Epoch 1/7, Batch 1400/1627, Embedding training loss: 1.0536\n", + "Epoch 1/7, Batch 1600/1627, Embedding training loss: 1.0086\n", + "Epoch 1 finished. \n", + "Average Training Embedding Loss: 1.0397\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.9755\n", + "\n", + "==== Training Epoch 2 ====\n", + "Epoch 2/7, Batch 200/1627, Embedding training loss: 0.9523\n", + "Epoch 2/7, Batch 400/1627, Embedding training loss: 0.9580\n", + "Epoch 2/7, Batch 600/1627, Embedding training loss: 1.0062\n", + "Epoch 2/7, Batch 800/1627, Embedding training loss: 0.9781\n", + "Epoch 2/7, Batch 1000/1627, Embedding training loss: 1.1699\n", + "Epoch 2/7, Batch 1200/1627, Embedding training loss: 0.9580\n", + "Epoch 2/7, Batch 1400/1627, Embedding training loss: 0.9493\n", + "Epoch 2/7, Batch 1600/1627, Embedding training loss: 1.0381\n", + "Epoch 2 finished. \n", + "Average Training Embedding Loss: 1.0099\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.3642\n", + "\n", + "==== Training Epoch 3 ====\n", + "Epoch 3/7, Batch 200/1627, Embedding training loss: 1.0660\n", + "Epoch 3/7, Batch 400/1627, Embedding training loss: 1.1197\n", + "Epoch 3/7, Batch 600/1627, Embedding training loss: 0.9338\n", + "Epoch 3/7, Batch 800/1627, Embedding training loss: 1.1626\n", + "Epoch 3/7, Batch 1000/1627, Embedding training loss: 1.0175\n", + "Epoch 3/7, Batch 1200/1627, Embedding training loss: 1.0149\n", + "Epoch 3/7, Batch 1400/1627, Embedding training loss: 0.9300\n", + "Epoch 3/7, Batch 1600/1627, Embedding training loss: 0.9963\n", + "Epoch 3 finished. \n", + "Average Training Embedding Loss: 1.0153\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.5090\n", + "\n", + "==== Training Epoch 4 ====\n", + "Epoch 4/7, Batch 200/1627, Embedding training loss: 0.8523\n", + "Epoch 4/7, Batch 400/1627, Embedding training loss: 0.8468\n", + "Epoch 4/7, Batch 600/1627, Embedding training loss: 1.0609\n", + "Epoch 4/7, Batch 800/1627, Embedding training loss: 1.0725\n", + "Epoch 4/7, Batch 1000/1627, Embedding training loss: 1.0503\n", + "Epoch 4/7, Batch 1200/1627, Embedding training loss: 1.0391\n", + "Epoch 4/7, Batch 1400/1627, Embedding training loss: 0.8811\n", + "Epoch 4/7, Batch 1600/1627, Embedding training loss: 1.0558\n", + "Epoch 4 finished. \n", + "Average Training Embedding Loss: 1.0154\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.4742\n", + "\n", + "==== Training Epoch 5 ====\n", + "Epoch 5/7, Batch 200/1627, Embedding training loss: 1.1731\n", + "Epoch 5/7, Batch 400/1627, Embedding training loss: 0.8620\n", + "Epoch 5/7, Batch 600/1627, Embedding training loss: 0.9244\n", + "Epoch 5/7, Batch 800/1627, Embedding training loss: 1.0486\n", + "Epoch 5/7, Batch 1000/1627, Embedding training loss: 1.1810\n", + "Epoch 5/7, Batch 1200/1627, Embedding training loss: 0.8051\n", + "Epoch 5/7, Batch 1400/1627, Embedding training loss: 0.8796\n", + "Epoch 5/7, Batch 1600/1627, Embedding training loss: 1.0491\n", + "Epoch 5 finished. \n", + "Average Training Embedding Loss: 1.0106\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.5228\n", + "\n", + "==== Training Epoch 6 ====\n", + "Epoch 6/7, Batch 200/1627, Embedding training loss: 0.9905\n", + "Epoch 6/7, Batch 400/1627, Embedding training loss: 0.8799\n", + "Epoch 6/7, Batch 600/1627, Embedding training loss: 1.0066\n", + "Epoch 6/7, Batch 800/1627, Embedding training loss: 1.0047\n", + "Epoch 6/7, Batch 1000/1627, Embedding training loss: 1.0231\n", + "Epoch 6/7, Batch 1200/1627, Embedding training loss: 1.0180\n", + "Epoch 6/7, Batch 1400/1627, Embedding training loss: 0.9366\n", + "Epoch 6/7, Batch 1600/1627, Embedding training loss: 0.8862\n", + "Epoch 6 finished. \n", + "Average Training Embedding Loss: 1.0099\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.3839\n", + "\n", + "==== Training Epoch 7 ====\n", + "Epoch 7/7, Batch 200/1627, Embedding training loss: 1.0897\n", + "Epoch 7/7, Batch 400/1627, Embedding training loss: 0.9968\n", + "Epoch 7/7, Batch 600/1627, Embedding training loss: 0.9966\n", + "Epoch 7/7, Batch 800/1627, Embedding training loss: 1.0164\n", + "Epoch 7/7, Batch 1000/1627, Embedding training loss: 1.1047\n", + "Epoch 7/7, Batch 1200/1627, Embedding training loss: 1.2214\n", + "Epoch 7/7, Batch 1400/1627, Embedding training loss: 1.0261\n", + "Epoch 7/7, Batch 1600/1627, Embedding training loss: 0.6800\n", + "Epoch 7 finished. \n", + "Average Training Embedding Loss: 1.0097\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.3572\n", + "Network training complete.\n" + ] + }, + { + "ename": "ValueError", + "evalue": "x and y must have same first dimension, but have shapes (7,) and (0,)", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[12]\u001b[39m\u001b[32m, line 33\u001b[39m\n\u001b[32m 30\u001b[39m classification_criterion = nn.CrossEntropyLoss().to(device)\n\u001b[32m 31\u001b[39m \u001b[38;5;66;03m#classifier_optimizer = optim.Adam(classifier_head.parameters(), lr=LEARNING_RATE)# * 5) # Faster learning rate for small head\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m33\u001b[39m \u001b[43mtrain_nets\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 34\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_loader\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 35\u001b[39m \u001b[43m \u001b[49m\u001b[43membedding_net\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43membedding_optimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 36\u001b[39m \u001b[43m \u001b[49m\u001b[43mtriplet_criterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclassification_criterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 37\u001b[39m \u001b[43m \u001b[49m\u001b[43membedding_scheduler\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 38\u001b[39m \u001b[43m \u001b[49m\u001b[32;43m7\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 39\u001b[39m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 114\u001b[39m, in \u001b[36mtrain_nets\u001b[39m\u001b[34m(train_loader, val_loader, embedding_net, embedding_opt, embedding_crit, classifier_crit, scheduler, epochs, device)\u001b[39m\n\u001b[32m 111\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mNetwork training complete.\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 113\u001b[39m \u001b[38;5;66;03m# Graphical display of metric logs\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m114\u001b[39m \u001b[43mplot_logs\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 115\u001b[39m \u001b[43m \u001b[49m\u001b[43memb_train_loss_log\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 116\u001b[39m \u001b[43m \u001b[49m\u001b[43mclas_train_loss_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 117\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_accuracy_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 118\u001b[39m \u001b[43m \u001b[49m\u001b[43memb_val_loss_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 119\u001b[39m \u001b[43m \u001b[49m\u001b[43mclas_val_loss_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 120\u001b[39m \u001b[43m \u001b[49m\u001b[43mval_accuracy_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 121\u001b[39m \u001b[43m \u001b[49m\u001b[43mval_ROC_AUC_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 122\u001b[39m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[10]\u001b[39m\u001b[32m, line 22\u001b[39m, in \u001b[36mplot_logs\u001b[39m\u001b[34m(emb_train_loss_log, clas_train_loss_log, train_accuracy_log, emb_val_loss_log, clas_val_loss_log, val_accuracy_log, val_ROC_AUC_log, epochs)\u001b[39m\n\u001b[32m 19\u001b[39m plt.legend()\n\u001b[32m 21\u001b[39m plt.subplot(\u001b[32m2\u001b[39m, \u001b[32m2\u001b[39m, \u001b[32m2\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m22\u001b[39m \u001b[43mplt\u001b[49m\u001b[43m.\u001b[49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclas_train_loss_log\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mTrain Loss\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolor\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m#F05039\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 23\u001b[39m plt.plot(\u001b[38;5;28mrange\u001b[39m(epochs), clas_val_loss_log, label=\u001b[33m'\u001b[39m\u001b[33mValidation Loss\u001b[39m\u001b[33m'\u001b[39m, color=\u001b[33m'\u001b[39m\u001b[33m#3D65A5\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m 24\u001b[39m plt.title(\u001b[33m'\u001b[39m\u001b[33mClassification Loss over Epochs\u001b[39m\u001b[33m'\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\matplotlib\\pyplot.py:3838\u001b[39m, in \u001b[36mplot\u001b[39m\u001b[34m(scalex, scaley, data, *args, **kwargs)\u001b[39m\n\u001b[32m 3830\u001b[39m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes.plot)\n\u001b[32m 3831\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mplot\u001b[39m(\n\u001b[32m 3832\u001b[39m *args: \u001b[38;5;28mfloat\u001b[39m | ArrayLike | \u001b[38;5;28mstr\u001b[39m,\n\u001b[32m (...)\u001b[39m\u001b[32m 3836\u001b[39m **kwargs,\n\u001b[32m 3837\u001b[39m ) -> \u001b[38;5;28mlist\u001b[39m[Line2D]:\n\u001b[32m-> \u001b[39m\u001b[32m3838\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgca\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 3839\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3840\u001b[39m \u001b[43m \u001b[49m\u001b[43mscalex\u001b[49m\u001b[43m=\u001b[49m\u001b[43mscalex\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3841\u001b[39m \u001b[43m \u001b[49m\u001b[43mscaley\u001b[49m\u001b[43m=\u001b[49m\u001b[43mscaley\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3842\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mdata\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m}\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m{\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3843\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3844\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\matplotlib\\axes\\_axes.py:1777\u001b[39m, in \u001b[36mAxes.plot\u001b[39m\u001b[34m(self, scalex, scaley, data, *args, **kwargs)\u001b[39m\n\u001b[32m 1534\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 1535\u001b[39m \u001b[33;03mPlot y versus x as lines and/or markers.\u001b[39;00m\n\u001b[32m 1536\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 1774\u001b[39m \u001b[33;03m(``'green'``) or hex strings (``'#008000'``).\u001b[39;00m\n\u001b[32m 1775\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 1776\u001b[39m kwargs = cbook.normalize_kwargs(kwargs, mlines.Line2D)\n\u001b[32m-> \u001b[39m\u001b[32m1777\u001b[39m lines = [*\u001b[38;5;28mself\u001b[39m._get_lines(\u001b[38;5;28mself\u001b[39m, *args, data=data, **kwargs)]\n\u001b[32m 1778\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m line \u001b[38;5;129;01min\u001b[39;00m lines:\n\u001b[32m 1779\u001b[39m \u001b[38;5;28mself\u001b[39m.add_line(line)\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\matplotlib\\axes\\_base.py:297\u001b[39m, in \u001b[36m_process_plot_var_args.__call__\u001b[39m\u001b[34m(self, axes, data, return_kwargs, *args, **kwargs)\u001b[39m\n\u001b[32m 295\u001b[39m this += args[\u001b[32m0\u001b[39m],\n\u001b[32m 296\u001b[39m args = args[\u001b[32m1\u001b[39m:]\n\u001b[32m--> \u001b[39m\u001b[32m297\u001b[39m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_plot_args\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 298\u001b[39m \u001b[43m \u001b[49m\u001b[43maxes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mthis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mambiguous_fmt_datakey\u001b[49m\u001b[43m=\u001b[49m\u001b[43mambiguous_fmt_datakey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 299\u001b[39m \u001b[43m \u001b[49m\u001b[43mreturn_kwargs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mreturn_kwargs\u001b[49m\n\u001b[32m 300\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\matplotlib\\axes\\_base.py:494\u001b[39m, in \u001b[36m_process_plot_var_args._plot_args\u001b[39m\u001b[34m(self, axes, tup, kwargs, return_kwargs, ambiguous_fmt_datakey)\u001b[39m\n\u001b[32m 491\u001b[39m axes.yaxis.update_units(y)\n\u001b[32m 493\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m x.shape[\u001b[32m0\u001b[39m] != y.shape[\u001b[32m0\u001b[39m]:\n\u001b[32m--> \u001b[39m\u001b[32m494\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mx and y must have same first dimension, but \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 495\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mhave shapes \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mx.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m and \u001b[39m\u001b[38;5;132;01m{\u001b[39;00my.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 496\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m x.ndim > \u001b[32m2\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m y.ndim > \u001b[32m2\u001b[39m:\n\u001b[32m 497\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mx and y can be no greater than 2D, but have \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 498\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mshapes \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mx.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m and \u001b[39m\u001b[38;5;132;01m{\u001b[39;00my.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", + "\u001b[31mValueError\u001b[39m: x and y must have same first dimension, but have shapes (7,) and (0,)" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", + "\n", + "train_dataset = SkinDataset(DATA_ROOT, \n", + " train_samples,\n", + " transform=transforms.Compose([\n", + " transforms.RandomRotation(degrees=10, fill=(255, 255, 255)),\n", + " transforms.RandomHorizontalFlip(p=0.5),\n", + " transforms.RandomVerticalFlip(p=0.5),\n", + " transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.05)\n", + " ]))\n", + "\n", + "val_dataset = SkinDataset(DATA_ROOT, val_samples, transform=None)\n", + "\n", + "# Use standard DataLoader; Triplet mining is handled in the custom loss\n", + "train_loader = DataLoader(train_dataset, batch_size=TRAIN_BATCH_SIZE, shuffle=True, drop_last=True, num_workers=0)\n", + "val_loader = DataLoader(val_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=0)\n", + "\n", + "# Model Setup\n", + "\n", + "# Embedding Net with Triplet Loss\n", + "embedding_net = EmbeddingNet(image_size=IMAGE_SIZE, out_dim=EMBEDDING_DIM).to(device)\n", + "triplet_criterion = BatchAllTtripletLoss(margin=MARGIN)\n", + "embedding_optimizer = optim.Adam(embedding_net.parameters(), lr=1e-5)\n", + "embedding_scheduler = optim.lr_scheduler.OneCycleLR(embedding_optimizer, max_lr=1e-5, steps_per_epoch=8,epochs=7, anneal_strategy=\"cos\")\n", + "#embedding_scheduler = optim.lr_scheduler.CyclicLR(embedding_optimizer, base_lr = 1e-8, max_lr = 1e-5, step_size_up = 4,mode = \"exp_range\")\n", + "#embedding_scheduler = optim.lr_scheduler.ReduceLROnPlateau(embedding_optimizer, mode='min', factor=0.5, patience=5)\n", + "\n", + "# Classification Head with Cross-Entropy Loss\n", + "#classifier_head = ClassificationNet(EMBEDDING_DIM).to(device)\n", + "classification_criterion = nn.CrossEntropyLoss().to(device)\n", + "#classifier_optimizer = optim.Adam(classifier_head.parameters(), lr=LEARNING_RATE)# * 5) # Faster learning rate for small head\n", + "\n", + "train_nets(\n", + " train_loader, val_loader,\n", + " embedding_net, embedding_optimizer, \n", + " triplet_criterion, classification_criterion, \n", + " embedding_scheduler,\n", + " 7, \n", + " device)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "efdf32b3", + "metadata": {}, + "outputs": [], + "source": [ + "def train_epoch(model, dataloader, criterion, optimizer):\n", + " model.train()\n", + " total_loss = 0.0\n", + " for img_a, img_p, img_n, _ in dataloader:\n", + " img_a, img_p, img_n = img_a.to(device), img_p.to(device), img_n.to(device)\n", + "\n", + " optimizer.zero_grad()\n", + " \n", + " # Get embeddings\n", + " emb_a = model(img_a)\n", + " emb_p = model(img_p)\n", + " emb_n = model(img_n)\n", + " \n", + " # Calculate loss\n", + " loss = criterion(emb_a, emb_p, emb_n)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " total_loss += loss.item() * img_a.size(0)\n", + "\n", + " return total_loss / len(dataloader.dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81422af3", + "metadata": {}, + "outputs": [], + "source": [ + "def train_epoch(model, dataloader, criterion, classification_crit, optimizer, scheduler, device):\n", + " model.train()\n", + " #total_loss = 0.0\n", + " all_labels = []\n", + " all_predictions = []\n", + " all_probs = []\n", + " emb_running_loss = 0.0\n", + " class_running_loss = 0.0\n", + " total_samples = 0\n", + " #print(\"la\")\n", + " for i, (img_a, img_p, img_n, label_a) in enumerate(dataloader):\n", + "\n", + " #print(\"yo\", i+1)\n", + " img_a, img_p, img_n = img_a.to(device), img_p.to(device), img_n.to(device)\n", + "\n", + " optimizer.zero_grad()\n", + " \n", + " # Get embeddings\n", + " emb_a = model(img_a)\n", + " emb_p = model(img_p)\n", + " emb_n = model(img_n)\n", + " # Calculate loss\n", + " emb_loss = criterion(emb_a, emb_p, emb_n)\n", + "\n", + " # classify anchors\n", + " out_a = model.classify(emb_a)\n", + " # Calculate classification loss\n", + " class_loss = classification_crit(out_a, label_a)\n", + "\n", + " loss = emb_loss + class_loss\n", + "\n", + " #print(\"ya\", loss.item())\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " #total_loss += loss.item() * img_a.size(0)\n", + " total_samples += img_a.size(0)\n", + " emb_running_loss += emb_loss.item() * img_a.size(0)\n", + " class_running_loss += class_loss.item() * img_a.size(0)\n", + "\n", + " # Predictions and Probabilities\n", + " _, preds = torch.max(out_a, 1)\n", + " probs = torch.softmax(out_a, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", + " all_labels.extend(label_a.cpu().numpy())\n", + " all_predictions.extend(preds.cpu().numpy())\n", + " all_probs.extend(probs.cpu().numpy())\n", + "\n", + " #print(\"on est passe\")\n", + "\n", + " if (i + 1) % 50 == 0:\n", + " print(f'Batch {i+1}/{len(dataloader)}, Embedding training loss: {(emb_loss.item()):.4f}, Classification training loss: {(class_loss.item()):.4f}')\n", + " #scheduler.step()\n", + "\n", + " if (i + 1) % 100 == 0:\n", + " scheduler.step()\n", + "\n", + " emb_epoch_loss = emb_running_loss / total_samples\n", + " class_epoch_loss = class_running_loss / total_samples\n", + " acc = accuracy_score(all_labels, all_predictions)\n", + " auc = roc_auc_score(all_labels, all_probs)\n", + " aps = average_precision_score(all_labels, all_probs)\n", + " return emb_epoch_loss, class_epoch_loss, acc, auc, aps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0c915db6", + "metadata": {}, + "outputs": [], + "source": [ + "def evaluate(model, dataloader, criterion, classification_crit, device):\n", + " \"\"\"\n", + " Evaluates the model by measuring inter-class distances.\n", + " A simple approach: treat the model as a binary classifier using distance to a fixed 'Normal' centroid.\n", + " NOTE: A more robust Siamese eval would use K-NN or a dedicated classification head.\n", + " \"\"\"\n", + " model.eval()\n", + " #embeddings = []\n", + " #labels = []\n", + " all_labels = []\n", + " all_predictions = []\n", + " all_probs = []\n", + " emb_running_loss = 0.0\n", + " class_running_loss = 0.0\n", + " total_samples = 0\n", + " \n", + " with torch.no_grad():\n", + " for _, (img_a, img_p, img_n, label_a) in enumerate(dataloader):\n", + "\n", + " #print(\"yo\", i+1)\n", + " img_a, img_p, img_n = img_a.to(device), img_p.to(device), img_n.to(device)\n", + " \n", + " # Get embeddings\n", + " emb_a = model(img_a)\n", + " emb_p = model(img_p)\n", + " emb_n = model(img_n)\n", + " # Calculate loss\n", + " emb_loss = criterion(emb_a, emb_p, emb_n)\n", + "\n", + " # classify anchors\n", + " out_a = model.classify(emb_a)\n", + " # Calculate classification loss\n", + " class_loss = classification_crit(out_a, label_a)\n", + " \n", + " #total_loss += loss.item() * img_a.size(0)\n", + " total_samples += img_a.size(0)\n", + " emb_running_loss += emb_loss.item() * img_a.size(0)\n", + " class_running_loss += class_loss.item() * img_a.size(0)\n", + "\n", + " # Predictions and Probabilities\n", + " _, preds = torch.max(out_a, 1)\n", + " probs = torch.softmax(out_a, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", + " all_labels.extend(label_a.cpu().numpy())\n", + " all_predictions.extend(preds.cpu().numpy())\n", + " all_probs.extend(probs.cpu().numpy())\n", + "\n", + " emb_epoch_loss = emb_running_loss / total_samples\n", + " class_epoch_loss = class_running_loss / total_samples\n", + " acc = accuracy_score(all_labels, all_predictions)\n", + " auc = roc_auc_score(all_labels, all_probs)\n", + " aps = average_precision_score(all_labels, all_probs)\n", + " return emb_epoch_loss, class_epoch_loss, acc, auc, aps" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d6d94681", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "20000//32//100\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9ed14bfb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3333.3333333333335" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "20000/6" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b07fb20d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "20000%6" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "196c123e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda\n", + "Number of normal samples in training data subset: 10449\n", + "Number of melanoma samples in training data subset: 10377\n", + "\n", + "--- Starting Training ---\n", + "ici\n", + "Batch 50/651, Embedding training loss: 1.0433\n", + "Batch 100/651, Embedding training loss: 0.9702\n", + "Batch 150/651, Embedding training loss: 0.9370\n", + "Batch 200/651, Embedding training loss: 0.9464\n", + "Batch 250/651, Embedding training loss: 0.9019\n", + "Batch 300/651, Embedding training loss: 1.0698\n", + "Batch 350/651, Embedding training loss: 1.0377\n", + "Batch 400/651, Embedding training loss: 0.9379\n", + "Batch 450/651, Embedding training loss: 0.9327\n", + "Batch 500/651, Embedding training loss: 1.0038\n", + "Batch 550/651, Embedding training loss: 1.0248\n", + "Batch 600/651, Embedding training loss: 0.9805\n", + "Batch 650/651, Embedding training loss: 0.9933\n", + "Epoch 1/20: | Train Loss: 1.0052 | Test Accuracy: 75.43% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.9941\n", + "Batch 100/651, Embedding training loss: 1.0060\n", + "Batch 150/651, Embedding training loss: 0.9492\n", + "Batch 200/651, Embedding training loss: 0.9877\n", + "Batch 250/651, Embedding training loss: 1.1558\n", + "Batch 300/651, Embedding training loss: 0.8516\n", + "Batch 350/651, Embedding training loss: 0.9338\n", + "Batch 400/651, Embedding training loss: 1.0534\n", + "Batch 450/651, Embedding training loss: 1.0293\n", + "Batch 500/651, Embedding training loss: 1.1635\n", + "Batch 550/651, Embedding training loss: 0.9603\n", + "Batch 600/651, Embedding training loss: 1.0423\n", + "Batch 650/651, Embedding training loss: 0.9754\n", + "Epoch 2/20: | Train Loss: 0.9991 | Test Accuracy: 74.74% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 1.0142\n", + "Batch 100/651, Embedding training loss: 1.0199\n", + "Batch 150/651, Embedding training loss: 0.7551\n", + "Batch 200/651, Embedding training loss: 1.0831\n", + "Batch 250/651, Embedding training loss: 0.8270\n", + "Batch 300/651, Embedding training loss: 0.8556\n", + "Batch 350/651, Embedding training loss: 0.8047\n", + "Batch 400/651, Embedding training loss: 0.9194\n", + "Batch 450/651, Embedding training loss: 0.8726\n", + "Batch 500/651, Embedding training loss: 1.0849\n", + "Batch 550/651, Embedding training loss: 0.9971\n", + "Batch 600/651, Embedding training loss: 0.6280\n", + "Batch 650/651, Embedding training loss: 0.6716\n", + "Epoch 3/20: | Train Loss: 0.9360 | Test Accuracy: 62.39% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.7339\n", + "Batch 100/651, Embedding training loss: 0.9860\n", + "Batch 150/651, Embedding training loss: 0.9713\n", + "Batch 200/651, Embedding training loss: 0.7792\n", + "Batch 250/651, Embedding training loss: 0.7460\n", + "Batch 300/651, Embedding training loss: 0.7465\n", + "Batch 350/651, Embedding training loss: 0.7027\n", + "Batch 400/651, Embedding training loss: 1.0381\n", + "Batch 450/651, Embedding training loss: 1.0057\n", + "Batch 500/651, Embedding training loss: 0.9338\n", + "Batch 550/651, Embedding training loss: 0.9754\n", + "Batch 600/651, Embedding training loss: 1.0169\n", + "Batch 650/651, Embedding training loss: 1.0257\n", + "Epoch 4/20: | Train Loss: 0.9090 | Test Accuracy: 57.17% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.8254\n", + "Batch 100/651, Embedding training loss: 0.7525\n", + "Batch 150/651, Embedding training loss: 1.0936\n", + "Batch 200/651, Embedding training loss: 0.7159\n", + "Batch 250/651, Embedding training loss: 0.9777\n", + "Batch 300/651, Embedding training loss: 1.0795\n", + "Batch 350/651, Embedding training loss: 0.6378\n", + "Batch 400/651, Embedding training loss: 0.9069\n", + "Batch 450/651, Embedding training loss: 0.6548\n", + "Batch 500/651, Embedding training loss: 1.0464\n", + "Batch 550/651, Embedding training loss: 0.9372\n", + "Batch 600/651, Embedding training loss: 0.9257\n", + "Batch 650/651, Embedding training loss: 0.6733\n", + "Epoch 5/20: | Train Loss: 0.8947 | Test Accuracy: 68.04% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.6817\n", + "Batch 100/651, Embedding training loss: 1.0117\n", + "Batch 150/651, Embedding training loss: 0.7493\n", + "Batch 200/651, Embedding training loss: 0.6283\n", + "Batch 250/651, Embedding training loss: 0.8177\n", + "Batch 300/651, Embedding training loss: 0.9655\n", + "Batch 350/651, Embedding training loss: 0.9284\n", + "Batch 400/651, Embedding training loss: 0.8662\n", + "Batch 450/651, Embedding training loss: 0.8936\n", + "Batch 500/651, Embedding training loss: 0.9434\n", + "Batch 550/651, Embedding training loss: 0.9057\n", + "Batch 600/651, Embedding training loss: 0.9025\n", + "Batch 650/651, Embedding training loss: 0.7762\n", + "Epoch 6/20: | Train Loss: 0.8613 | Test Accuracy: 68.25% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.7871\n", + "Batch 100/651, Embedding training loss: 0.8442\n", + "Batch 150/651, Embedding training loss: 0.9525\n", + "Batch 200/651, Embedding training loss: 0.9400\n", + "Batch 250/651, Embedding training loss: 0.9582\n", + "Batch 300/651, Embedding training loss: 0.8132\n", + "Batch 350/651, Embedding training loss: 0.7650\n", + "Batch 400/651, Embedding training loss: 1.0256\n", + "Batch 450/651, Embedding training loss: 0.8973\n", + "Batch 500/651, Embedding training loss: 0.8756\n", + "Batch 550/651, Embedding training loss: 1.0567\n", + "Batch 600/651, Embedding training loss: 0.6825\n", + "Batch 650/651, Embedding training loss: 0.7767\n", + "Epoch 7/20: | Train Loss: 0.8357 | Test Accuracy: 66.41% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.8511\n", + "Batch 100/651, Embedding training loss: 1.0448\n", + "Batch 150/651, Embedding training loss: 0.7865\n", + "Batch 200/651, Embedding training loss: 0.8027\n", + "Batch 250/651, Embedding training loss: 1.0012\n", + "Batch 300/651, Embedding training loss: 0.8322\n", + "Batch 350/651, Embedding training loss: 0.6300\n", + "Batch 400/651, Embedding training loss: 0.6963\n", + "Batch 450/651, Embedding training loss: 0.6841\n", + "Batch 500/651, Embedding training loss: 0.6477\n", + "Batch 550/651, Embedding training loss: 0.9165\n", + "Batch 600/651, Embedding training loss: 0.4800\n", + "Batch 650/651, Embedding training loss: 0.8581\n", + "Epoch 8/20: | Train Loss: 0.8226 | Test Accuracy: 69.48% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 1.0554\n", + "Batch 100/651, Embedding training loss: 0.7125\n", + "Batch 150/651, Embedding training loss: 0.6354\n", + "Batch 200/651, Embedding training loss: 0.9703\n", + "Batch 250/651, Embedding training loss: 0.8246\n", + "Batch 300/651, Embedding training loss: 0.6126\n", + "Batch 350/651, Embedding training loss: 0.9045\n", + "Batch 400/651, Embedding training loss: 0.7606\n", + "Batch 450/651, Embedding training loss: 0.8058\n", + "Batch 500/651, Embedding training loss: 0.8063\n", + "Batch 550/651, Embedding training loss: 1.1629\n", + "Batch 600/651, Embedding training loss: 0.7261\n", + "Batch 650/651, Embedding training loss: 0.6894\n", + "Epoch 9/20: | Train Loss: 0.7947 | Test Accuracy: 70.57% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.8882\n", + "Batch 100/651, Embedding training loss: 0.7655\n", + "Batch 150/651, Embedding training loss: 0.6591\n", + "Batch 200/651, Embedding training loss: 0.7328\n", + "Batch 250/651, Embedding training loss: 0.7122\n", + "Batch 300/651, Embedding training loss: 0.7530\n", + "Batch 350/651, Embedding training loss: 0.6809\n", + "Batch 400/651, Embedding training loss: 0.6446\n", + "Batch 450/651, Embedding training loss: 0.7506\n", + "Batch 500/651, Embedding training loss: 0.8855\n", + "Batch 550/651, Embedding training loss: 0.8850\n", + "Batch 600/651, Embedding training loss: 0.7865\n", + "Batch 650/651, Embedding training loss: 1.0001\n", + "Epoch 10/20: | Train Loss: 0.7864 | Test Accuracy: 69.15% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.7409\n", + "Batch 100/651, Embedding training loss: 0.7351\n", + "Batch 150/651, Embedding training loss: 0.8151\n", + "Batch 200/651, Embedding training loss: 0.7091\n", + "Batch 250/651, Embedding training loss: 0.8767\n", + "Batch 300/651, Embedding training loss: 0.7184\n", + "Batch 350/651, Embedding training loss: 0.6895\n", + "Batch 400/651, Embedding training loss: 1.0286\n", + "Batch 450/651, Embedding training loss: 0.6628\n", + "Batch 500/651, Embedding training loss: 0.9155\n", + "Batch 550/651, Embedding training loss: 0.7207\n", + "Batch 600/651, Embedding training loss: 0.9877\n", + "Batch 650/651, Embedding training loss: 0.7152\n", + "Epoch 11/20: | Train Loss: 0.7688 | Test Accuracy: 70.48% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.8553\n", + "Batch 100/651, Embedding training loss: 0.5856\n", + "Batch 150/651, Embedding training loss: 0.4819\n", + "Batch 200/651, Embedding training loss: 0.8288\n", + "Batch 250/651, Embedding training loss: 0.7959\n", + "Batch 300/651, Embedding training loss: 0.5806\n", + "Batch 350/651, Embedding training loss: 0.9526\n", + "Batch 400/651, Embedding training loss: 0.9973\n", + "Batch 450/651, Embedding training loss: 0.6407\n", + "Batch 500/651, Embedding training loss: 0.7815\n", + "Batch 550/651, Embedding training loss: 0.6542\n", + "Batch 600/651, Embedding training loss: 0.8451\n", + "Batch 650/651, Embedding training loss: 0.8146\n", + "Epoch 12/20: | Train Loss: 0.7585 | Test Accuracy: 74.19% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.8715\n", + "Batch 100/651, Embedding training loss: 0.7170\n", + "Batch 150/651, Embedding training loss: 0.8354\n", + "Batch 200/651, Embedding training loss: 1.0796\n", + "Batch 250/651, Embedding training loss: 0.7759\n", + "Batch 300/651, Embedding training loss: 0.6996\n", + "Batch 350/651, Embedding training loss: 0.5027\n", + "Batch 400/651, Embedding training loss: 0.8089\n", + "Batch 450/651, Embedding training loss: 0.7181\n", + "Batch 500/651, Embedding training loss: 0.7225\n", + "Batch 550/651, Embedding training loss: 0.6912\n", + "Batch 600/651, Embedding training loss: 0.6742\n", + "Batch 650/651, Embedding training loss: 0.5089\n", + "Epoch 13/20: | Train Loss: 0.7376 | Test Accuracy: 75.04% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.5103\n", + "Batch 100/651, Embedding training loss: 0.7334\n", + "Batch 150/651, Embedding training loss: 0.6978\n", + "Batch 200/651, Embedding training loss: 0.7160\n", + "Batch 250/651, Embedding training loss: 0.7911\n", + "Batch 300/651, Embedding training loss: 0.9181\n", + "Batch 350/651, Embedding training loss: 0.5724\n", + "Batch 400/651, Embedding training loss: 0.4896\n", + "Batch 450/651, Embedding training loss: 0.7514\n", + "Batch 500/651, Embedding training loss: 0.6514\n", + "Batch 550/651, Embedding training loss: 0.6107\n", + "Batch 600/651, Embedding training loss: 0.6755\n", + "Batch 650/651, Embedding training loss: 0.7436\n", + "Epoch 14/20: | Train Loss: 0.7089 | Test Accuracy: 77.33% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.6720\n", + "Batch 100/651, Embedding training loss: 0.8618\n", + "Batch 150/651, Embedding training loss: 0.6614\n", + "Batch 200/651, Embedding training loss: 0.7899\n", + "Batch 250/651, Embedding training loss: 0.6115\n", + "Batch 300/651, Embedding training loss: 0.6203\n", + "Batch 350/651, Embedding training loss: 0.5912\n", + "Batch 400/651, Embedding training loss: 0.5593\n", + "Batch 450/651, Embedding training loss: 0.6098\n", + "Batch 500/651, Embedding training loss: 0.7040\n", + "Batch 550/651, Embedding training loss: 0.6199\n", + "Batch 600/651, Embedding training loss: 0.6339\n", + "Batch 650/651, Embedding training loss: 0.4569\n", + "Epoch 15/20: | Train Loss: 0.6828 | Test Accuracy: 77.36% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.5399\n", + "Batch 100/651, Embedding training loss: 0.5418\n", + "Batch 150/651, Embedding training loss: 1.1730\n", + "Batch 200/651, Embedding training loss: 0.7682\n", + "Batch 250/651, Embedding training loss: 0.5464\n", + "Batch 300/651, Embedding training loss: 0.7292\n", + "Batch 350/651, Embedding training loss: 0.6012\n", + "Batch 400/651, Embedding training loss: 0.8411\n", + "Batch 450/651, Embedding training loss: 0.7385\n", + "Batch 500/651, Embedding training loss: 0.7424\n", + "Batch 550/651, Embedding training loss: 0.7475\n", + "Batch 600/651, Embedding training loss: 0.6158\n", + "Batch 650/651, Embedding training loss: 0.8267\n", + "Epoch 16/20: | Train Loss: 0.6583 | Test Accuracy: 82.16% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.6916\n", + "Batch 100/651, Embedding training loss: 0.6542\n", + "Batch 150/651, Embedding training loss: 0.7077\n", + "Batch 200/651, Embedding training loss: 0.7248\n", + "Batch 250/651, Embedding training loss: 0.5061\n", + "Batch 300/651, Embedding training loss: 0.3420\n", + "Batch 350/651, Embedding training loss: 0.4552\n", + "Batch 400/651, Embedding training loss: 0.7127\n", + "Batch 450/651, Embedding training loss: 0.4834\n", + "Batch 500/651, Embedding training loss: 0.4366\n", + "Batch 550/651, Embedding training loss: 0.6212\n", + "Batch 600/651, Embedding training loss: 0.6471\n", + "Batch 650/651, Embedding training loss: 0.5009\n", + "Epoch 17/20: | Train Loss: 0.6363 | Test Accuracy: 76.43% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.6375\n", + "Batch 100/651, Embedding training loss: 0.4805\n", + "Batch 150/651, Embedding training loss: 0.6764\n", + "Batch 200/651, Embedding training loss: 0.7939\n", + "Batch 250/651, Embedding training loss: 0.4486\n", + "Batch 300/651, Embedding training loss: 0.6346\n", + "Batch 350/651, Embedding training loss: 0.5725\n", + "Batch 400/651, Embedding training loss: 0.6113\n", + "Batch 450/651, Embedding training loss: 0.6076\n", + "Batch 500/651, Embedding training loss: 0.7885\n", + "Batch 550/651, Embedding training loss: 0.7369\n", + "Batch 600/651, Embedding training loss: 0.6087\n", + "Batch 650/651, Embedding training loss: 0.4526\n", + "Epoch 18/20: | Train Loss: 0.6053 | Test Accuracy: 80.14% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 0.6482\n", + "Batch 100/651, Embedding training loss: 0.5784\n", + "Batch 150/651, Embedding training loss: 0.7174\n", + "Batch 200/651, Embedding training loss: 0.5573\n", + "Batch 250/651, Embedding training loss: 0.7378\n", + "Batch 300/651, Embedding training loss: 0.5528\n", + "Batch 350/651, Embedding training loss: 0.5017\n", + "Batch 400/651, Embedding training loss: 0.3908\n", + "Batch 450/651, Embedding training loss: 0.5170\n", + "Batch 500/651, Embedding training loss: 0.4614\n", + "Batch 550/651, Embedding training loss: 0.4944\n", + "Batch 600/651, Embedding training loss: 0.5471\n", + "Batch 650/651, Embedding training loss: 0.5593\n", + "Epoch 19/20: | Train Loss: 0.5877 | Test Accuracy: 80.89% (3313 samples)\n", + "ici\n", + "Batch 50/651, Embedding training loss: 1.0096\n", + "Batch 100/651, Embedding training loss: 0.3865\n", + "Batch 150/651, Embedding training loss: 0.6385\n", + "Batch 200/651, Embedding training loss: 0.6560\n", + "Batch 250/651, Embedding training loss: 0.4407\n", + "Batch 300/651, Embedding training loss: 0.4531\n", + "Batch 350/651, Embedding training loss: 0.3855\n", + "Batch 400/651, Embedding training loss: 0.4408\n", + "Batch 450/651, Embedding training loss: 0.5973\n", + "Batch 500/651, Embedding training loss: 0.4610\n", + "Batch 550/651, Embedding training loss: 0.4459\n", + "Batch 600/651, Embedding training loss: 0.6158\n", + "Batch 650/651, Embedding training loss: 0.5478\n", + "Epoch 20/20: | Train Loss: 0.5822 | Test Accuracy: 80.50% (3313 samples)\n", + "\n", + "--- Training Finished ---\n", + "Best Test Accuracy: 0.00%\n", + "Goal: Achieve accuracy around 0.8 (80.00%) using Triplet Loss for robust melanoma classification.\n" + ] + } + ], + "source": [ + "print(f\"Using device: {device}\")\n", + "\n", + "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", + "train_samples = train_samples.sample(frac=0.4).reset_index(drop=True)\n", + "print(f\"Number of normal samples in training data subset: {train_samples[train_samples[\"target\"]== 0].shape[0]}\")\n", + "print(f\"Number of melanoma samples in training data subset: {train_samples[train_samples[\"target\"]== 1].shape[0]}\")\n", + "\n", + "# Setup DataLoaders\n", + "train_dataset = TripletDataset(DATA_ROOT, train_samples,\n", + " transform=transforms.Compose([\n", + " transforms.RandomRotation(degrees=15, fill=(255, 255, 255)),\n", + " transforms.RandomHorizontalFlip(p=0.5),\n", + " transforms.RandomVerticalFlip(p=0.5),\n", + " transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.05)\n", + " ]))\n", + "\n", + "val_dataset = TripletDataset(DATA_ROOT, val_samples, transform=None)\n", + "\n", + "\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=0)\n", + "val_loader = DataLoader(val_dataset, batch_size=256, shuffle=True, num_workers=0)\n", + "\n", + "# Setup Model, Loss, Optimizer\n", + "model = EmbeddingNet(out_dim=EMBEDDING_DIM).to(device)\n", + "#model = SiameseNet(embedding_net).to(device)\n", + "criterion = TripletLoss(margin=MARGIN).to(device)\n", + "classifier_crit = nn.CrossEntropyLoss().to(device)\n", + "optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)\n", + "scheduler = optim.lr_scheduler.OneCycleLR(optimizer, max_lr=LEARNING_RATE, steps_per_epoch=train_samples.shape[0]//32//100,epochs=NUM_EPOCHS, anneal_strategy=\"cos\")\n", + "\n", + "# Training Loop\n", + "best_val_AP_score = -1.0\n", + "# metric logging\n", + "emb_train_loss_log = []\n", + "emb_val_loss_log = []\n", + "clas_train_loss_log = []\n", + "clas_val_loss_log = []\n", + "train_accuracy_log = []\n", + "val_accuracy_log = []\n", + "train_ROC_AUC_log = []\n", + "val_ROC_AUC_log = []\n", + "train_AP_score_log = []\n", + "val_AP_score_log = []\n", + "\n", + "print(\"\\n--- Starting Training ---\")\n", + "for epoch in range(1, NUM_EPOCHS + 1):\n", + " # Train\n", + " print(f\"\\n==== Training Epoch {epoch} ====\")\n", + " emb_train_loss, class_train_loss, train_acc, train_auc, train_aps = train_epoch(model, train_loader, criterion, classifier_crit, optimizer, scheduler, device)\n", + "\n", + " print(f\"Epoch {epoch} training finished.\")\n", + " print(f\"Average Training Embedding Loss: {emb_train_loss:.4f}\")\n", + " print(f\"Average Training Classification Loss: {class_train_loss:.4f}\")\n", + " print(f\"Training Classification Accuracy: {train_acc:.4f}\")\n", + " print(f\"Training ROC AUC: {train_auc:.4f}\")\n", + " print(f\"Training Average Precision Score: {train_aps:.4f}\")\n", + "\n", + " emb_train_loss_log.append(emb_train_loss)\n", + " clas_train_loss_log.append(class_train_loss)\n", + " train_accuracy_log.append(train_acc)\n", + " train_ROC_AUC_log.append(train_auc)\n", + " train_AP_score_log.append(train_aps)\n", + " \n", + " # Evaluate\n", + " emb_val_loss, class_val_loss, val_acc, val_auc, val_aps = evaluate(model, val_loader, criterion, classifier_crit, device)\n", + " \n", + " print(\"--- Validation phase ---\")\n", + " print(f\"Average Validation Embedding Loss: {emb_val_loss:.4f}\")\n", + " print(f\"Average Validation Classification Loss: {class_val_loss:.4f}\")\n", + " print(f\"Validation Classification Accuracy: {val_acc:.4f}\")\n", + " print(f\"Validation ROC AUC: {val_auc:.4f}\")\n", + " print(f\"Validation Average Precision Score: {val_aps:.4f}\")\n", + "\n", + " emb_val_loss_log.append(emb_val_loss)\n", + " clas_val_loss_log.append(class_val_loss)\n", + " val_accuracy_log.append(val_acc)\n", + " val_ROC_AUC_log.append(val_auc)\n", + " val_AP_score_log.append(val_aps)\n", + "\n", + " # Save best model\n", + " if val_aps > best_val_AP_score:\n", + " print(f\"Previous best average precision score: {best_val_AP_score:.4f}\")\n", + " best_val_AP_score = val_aps\n", + " print(\"Saving best model...\")\n", + " torch.save(model.state_dict(), (Path(DATA_ROOT) / 'best_siamese_model.pth'))\n", + " \n", + "print(\"\\n--- Training Finished ---\")\n", + "print(f\"Best Validation Average Precision Score: {best_val_AP_score:.4f}%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "d316ab2a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- Training Networks ---\n", + "\n", + "==== Training Epoch 1 ====\n", + "1.4105521440505981 90.27533721923828 0.6941325664520264 44.42448425292969\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n", + "nan nan nan nan\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[35]\u001b[39m\u001b[32m, line 67\u001b[39m\n\u001b[32m 63\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33m==== Training Epoch \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m ====\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 65\u001b[39m \u001b[38;5;66;03m# --- Training phase ----\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m67\u001b[39m \u001b[43m\u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mimages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 68\u001b[39m \u001b[43m \u001b[49m\u001b[43mimages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[43mimages\u001b[49m\u001b[43m.\u001b[49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m.\u001b[49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 69\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#print(i)\u001b[39;49;00m\n\u001b[32m 70\u001b[39m \n\u001b[32m 71\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# ---- Embedding model training ----\u001b[39;49;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\utils\\data\\dataloader.py:734\u001b[39m, in \u001b[36m_BaseDataLoaderIter.__next__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 731\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._sampler_iter \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 732\u001b[39m \u001b[38;5;66;03m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[39;00m\n\u001b[32m 733\u001b[39m \u001b[38;5;28mself\u001b[39m._reset() \u001b[38;5;66;03m# type: ignore[call-arg]\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m734\u001b[39m data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_next_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 735\u001b[39m \u001b[38;5;28mself\u001b[39m._num_yielded += \u001b[32m1\u001b[39m\n\u001b[32m 736\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[32m 737\u001b[39m \u001b[38;5;28mself\u001b[39m._dataset_kind == _DatasetKind.Iterable\n\u001b[32m 738\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._IterableDataset_len_called \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 739\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._num_yielded > \u001b[38;5;28mself\u001b[39m._IterableDataset_len_called\n\u001b[32m 740\u001b[39m ):\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\utils\\data\\dataloader.py:790\u001b[39m, in \u001b[36m_SingleProcessDataLoaderIter._next_data\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 788\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_next_data\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 789\u001b[39m index = \u001b[38;5;28mself\u001b[39m._next_index() \u001b[38;5;66;03m# may raise StopIteration\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m790\u001b[39m data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_dataset_fetcher\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfetch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindex\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# may raise StopIteration\u001b[39;00m\n\u001b[32m 791\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._pin_memory:\n\u001b[32m 792\u001b[39m data = _utils.pin_memory.pin_memory(data, \u001b[38;5;28mself\u001b[39m._pin_memory_device)\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\utils\\data\\_utils\\fetch.py:52\u001b[39m, in \u001b[36m_MapDatasetFetcher.fetch\u001b[39m\u001b[34m(self, possibly_batched_index)\u001b[39m\n\u001b[32m 50\u001b[39m data = \u001b[38;5;28mself\u001b[39m.dataset.__getitems__(possibly_batched_index)\n\u001b[32m 51\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m52\u001b[39m data = [\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mdataset\u001b[49m\u001b[43m[\u001b[49m\u001b[43midx\u001b[49m\u001b[43m]\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m idx \u001b[38;5;129;01min\u001b[39;00m possibly_batched_index]\n\u001b[32m 53\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 54\u001b[39m data = \u001b[38;5;28mself\u001b[39m.dataset[possibly_batched_index]\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 37\u001b[39m, in \u001b[36mSkinDataset.__getitem__\u001b[39m\u001b[34m(self, idx)\u001b[39m\n\u001b[32m 35\u001b[39m image = Image.open(\u001b[38;5;28mself\u001b[39m.image_dir / (image_name + \u001b[33m\"\u001b[39m\u001b[33m.jpg\u001b[39m\u001b[33m\"\u001b[39m)).convert(\u001b[33m'\u001b[39m\u001b[33mRGB\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m 36\u001b[39m \u001b[38;5;66;03m# Transform image\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m37\u001b[39m image = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 39\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m image, torch.tensor(label, dtype=torch.long)\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\transforms\\transforms.py:95\u001b[39m, in \u001b[36mCompose.__call__\u001b[39m\u001b[34m(self, img)\u001b[39m\n\u001b[32m 93\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, img):\n\u001b[32m 94\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m t \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.transforms:\n\u001b[32m---> \u001b[39m\u001b[32m95\u001b[39m img = \u001b[43mt\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 96\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m img\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1773\u001b[39m, in \u001b[36mModule._wrapped_call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 1771\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._compiled_call_impl(*args, **kwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[32m 1772\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1773\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1784\u001b[39m, in \u001b[36mModule._call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 1779\u001b[39m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[32m 1780\u001b[39m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[32m 1781\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m._backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_pre_hooks\n\u001b[32m 1782\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[32m 1783\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[32m-> \u001b[39m\u001b[32m1784\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1786\u001b[39m result = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 1787\u001b[39m called_always_called_hooks = \u001b[38;5;28mset\u001b[39m()\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\transforms\\transforms.py:1280\u001b[39m, in \u001b[36mColorJitter.forward\u001b[39m\u001b[34m(self, img)\u001b[39m\n\u001b[32m 1278\u001b[39m img = F.adjust_saturation(img, saturation_factor)\n\u001b[32m 1279\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m fn_id == \u001b[32m3\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m hue_factor \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1280\u001b[39m img = \u001b[43mF\u001b[49m\u001b[43m.\u001b[49m\u001b[43madjust_hue\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhue_factor\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1282\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m img\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\transforms\\functional.py:934\u001b[39m, in \u001b[36madjust_hue\u001b[39m\u001b[34m(img, hue_factor)\u001b[39m\n\u001b[32m 929\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m F_pil.adjust_saturation(img, saturation_factor)\n\u001b[32m 931\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m F_t.adjust_saturation(img, saturation_factor)\n\u001b[32m--> \u001b[39m\u001b[32m934\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34madjust_hue\u001b[39m(img: Tensor, hue_factor: \u001b[38;5;28mfloat\u001b[39m) -> Tensor:\n\u001b[32m 935\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Adjust hue of an image.\u001b[39;00m\n\u001b[32m 936\u001b[39m \n\u001b[32m 937\u001b[39m \u001b[33;03m The image hue is adjusted by converting the image to HSV and\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 963\u001b[39m \u001b[33;03m PIL Image or Tensor: Hue adjusted image.\u001b[39;00m\n\u001b[32m 964\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m 965\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m torch.jit.is_scripting() \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m torch.jit.is_tracing():\n", + "\u001b[31mKeyboardInterrupt\u001b[39m: " + ] + } + ], + "source": [ + "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", + "\n", + "train_dataset = SkinDataset(DATA_ROOT, \n", + " train_samples,\n", + " transform=transforms.Compose([\n", + " transforms.RandomRotation(degrees=15, fill=(255, 255, 255)),\n", + " transforms.RandomHorizontalFlip(p=0.5),\n", + " transforms.RandomVerticalFlip(p=0.5),\n", + " transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.05)\n", + " ]))\n", + "\n", + "val_dataset = SkinDataset(DATA_ROOT, val_samples, transform=None)\n", + "\n", + "# Use standard DataLoader; Triplet mining is handled in the custom loss\n", + "train_loader = DataLoader(train_dataset, batch_size=TRAIN_BATCH_SIZE, shuffle=True, drop_last=True, num_workers=0)\n", + "val_loader = DataLoader(val_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=0)\n", + "\n", + "# Model Setup\n", + "\n", + "# Embedding Net with Triplet Loss\n", + "embedding_net = EmbeddingNet(image_size=IMAGE_SIZE, out_dim=EMBEDDING_DIM).to(device)\n", + "embedding_crit = TripletMarginLoss(margin=MARGIN)\n", + "embedding_opt = optim.Adam(embedding_net.parameters(), lr=LEARNING_RATE)\n", + "scheduler = optim.lr_scheduler.ReduceLROnPlateau(embedding_opt, mode='max', factor=0.5, patience=5)\n", + "\n", + "# Classification Head with Cross-Entropy Loss\n", + "classifier_net = ClassificationNet(EMBEDDING_DIM).to(device)\n", + "classifier_crit = nn.CrossEntropyLoss().to(device)\n", + "classifier_opt = optim.Adam(classifier_net.parameters(), lr=LEARNING_RATE)# * 5) # Faster learning rate for small head\n", + "\n", + "epochs = NUM_EPOCHS\n", + "#train_nets(\n", + "# embedding_net, classifier_head, \n", + "# train_loader, val_loader, \n", + "# triplet_criterion, classification_criterion, \n", + "# embedding_optimizer, classifier_optimizer, \n", + "# embedding_scheduler,\n", + "# NUM_EPOCHS, \n", + "# device)\n", + "\n", + "\n", + "\n", + "print(\"\\n--- Training Networks ---\")\n", + "\n", + "# metric logging intialisation\n", + "best_val_ROC_AUC = -1.0\n", + "emb_train_loss_log = []\n", + "clas_train_loss_log = []\n", + "train_accuracy_log = []\n", + "emb_val_loss_log = []\n", + "clas_val_loss_log = []\n", + "val_accuracy_log = []\n", + "val_ROC_AUC_log = []\n", + "\n", + "for epoch in range(1, epochs + 1):\n", + " embedding_net.train()\n", + " classifier_net.train()\n", + " emb_running_loss = 0.0\n", + " clas_running_loss = 0.0\n", + " correct_predictions = 0\n", + " total_samples = 0\n", + "\n", + " print(f\"\\n==== Training Epoch {epoch} ====\")\n", + "\n", + " # --- Training phase ----\n", + "\n", + " for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + " #print(i)\n", + "\n", + " # ---- Embedding model training ----\n", + " \n", + " embedding_opt.zero_grad()\n", + " classifier_opt.zero_grad()\n", + " # Generate embeddings\n", + " embeddings = embedding_net(images)\n", + " \n", + " # Calculate Triplet Loss using Batch-Hard mining\n", + " emb_loss = embedding_crit(embeddings, labels)\n", + " \n", + " # ---- Classification model training ----\n", + " \n", + " \n", + " # Classify\n", + " outputs = classifier_net(embeddings)\n", + " clas_loss = classifier_crit(outputs, labels)\n", + "\n", + " # Statistics\n", + " emb_running_loss += emb_loss.item() * len(images)\n", + " clas_running_loss += clas_loss.item() * len(images)\n", + " _, preds = torch.max(outputs, 1)\n", + " correct_predictions += torch.sum(preds == labels.data).item()\n", + " total_samples += len(images)\n", + "\n", + " print(emb_loss.item(), emb_running_loss, clas_loss.item(), clas_running_loss)\n", + " if (i + 1) % 50 == 0:\n", + " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_loss.item()):.4f}, Classification training loss: {(clas_loss.item()):.4f}')\n", + " #print(clas_loss)\n", + "\n", + " total_loss = emb_loss + clas_loss\n", + "\n", + " \n", + " total_loss.backward()\n", + " embedding_opt.step()\n", + " classifier_opt.step()\n", + "\n", + " # embedding training epoch loss\n", + " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", + " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", + "\n", + " # classification training epoch loss\n", + " clas_epoch_loss = clas_running_loss / total_samples\n", + " epoch_acc = correct_predictions / total_samples\n", + " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", + " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", + "\n", + " # ---- Evaluation phase ----\n", + "\n", + " print(\"--- Validation phase ---\")\n", + " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", + " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", + " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", + " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", + " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", + "\n", + " # metric logging for plotting\n", + " emb_train_loss_log.append(emb_epoch_loss)\n", + " clas_train_loss_log.append(clas_epoch_loss)\n", + " train_accuracy_log.append(epoch_acc)\n", + " emb_val_loss_log.append(val_emb_loss)\n", + " clas_val_loss_log.append(val_clas_loss)\n", + " val_accuracy_log.append(epoch_val_accuracy)\n", + " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", + "\n", + " scheduler.step(epoch_val_ROC_AUC)\n", + "\n", + " # save best model based on ROC AUC\n", + " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", + " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", + " best_val_ROC_AUC = epoch_val_ROC_AUC\n", + " # Save model checkpoint\n", + " print(\"Saving best model...\")\n", + " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", + " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", + "\n", + "\n", + "print(\"Network training complete.\")\n", + "\n", + "# Graphical display of metric logs\n", + "plot_logs(\n", + " emb_train_loss_log, \n", + " clas_train_loss_log,\n", + " train_accuracy_log,\n", + " emb_val_loss_log,\n", + " clas_val_loss_log,\n", + " val_accuracy_log,\n", + " val_ROC_AUC_log,\n", + " epochs)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "911f3e5c", + "metadata": {}, + "outputs": [], + "source": [ + "# metric logging intialisation\n", + "best_val_ROC_AUC = -1.0\n", + "emb_train_loss_log = []\n", + "clas_train_loss_log = []\n", + "train_accuracy_log = []\n", + "emb_val_loss_log = []\n", + "clas_val_loss_log = []\n", + "val_accuracy_log = []\n", + "val_ROC_AUC_log = []" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4fda77d1", + "metadata": {}, + "outputs": [], + "source": [ + "embedding_net.train()\n", + "classifier_head.train()\n", + "emb_running_loss = 0.0\n", + "clas_running_loss = 0.0\n", + "correct_predictions = 0\n", + "total_samples = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "572a2cb9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[[2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " ...,\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", + "\n", + " [[2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " ...,\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", + "\n", + " [[2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " ...,\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", + "\n", + "\n", + " [[[2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", + " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", + " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", + " ...,\n", + " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", + " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", + " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948]],\n", + "\n", + " [[2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", + " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", + " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", + " ...,\n", + " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", + " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", + " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710]],\n", + "\n", + " [[2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", + " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", + " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", + " ...,\n", + " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", + " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", + " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831]]],\n", + "\n", + "\n", + " [[[2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " ...,\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", + "\n", + " [[2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " ...,\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", + "\n", + " [[2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " ...,\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + " [[[2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " ...,\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", + "\n", + " [[2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " ...,\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", + "\n", + " [[2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " ...,\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", + "\n", + "\n", + " [[[2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", + " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", + " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", + " ...,\n", + " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", + " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", + " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605]],\n", + "\n", + " [[2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", + " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", + " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", + " ...,\n", + " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", + " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", + " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360]],\n", + "\n", + " [[2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", + " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", + " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", + " ...,\n", + " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", + " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", + " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483]]],\n", + "\n", + "\n", + " [[[1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", + " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", + " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", + " ...,\n", + " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", + " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", + " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920]],\n", + "\n", + " [[2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", + " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", + " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", + " ...,\n", + " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", + " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", + " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660]],\n", + "\n", + " [[2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", + " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", + " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", + " ...,\n", + " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", + " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", + " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786]]]],\n", + " device='cuda:0')\n", + "tensor([0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0,\n", + " 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1,\n", + " 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0], device='cuda:0')\n" + ] + } + ], + "source": [ + "for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + " if i == 0:\n", + " break\n", + "\n", + "print(images)\n", + "print(labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "b8fcc614", + "metadata": {}, + "outputs": [], + "source": [ + "embeddings = embedding_net(images)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "c4aef745", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([64, 3, 256, 256])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "8ed15396", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([64, 128])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "embeddings.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "07b488b6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " ...,\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]], device='cuda:0',\n", + " grad_fn=)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "59739384", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(nan, device='cuda:0', grad_fn=)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "emb_loss = triplet_criterion(embeddings, labels)\n", + "emb_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0b1762df", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0.0479, 0.0744],\n", + " [ 0.0237, 0.0800],\n", + " [ 0.0478, 0.0973],\n", + " [ 0.0512, 0.0786],\n", + " [ 0.0393, 0.0880],\n", + " [ 0.0464, 0.0743],\n", + " [ 0.0111, 0.0674],\n", + " [ 0.0576, 0.0923],\n", + " [ 0.0611, 0.0609],\n", + " [ 0.0347, 0.0788],\n", + " [ 0.0382, 0.0774],\n", + " [ 0.0160, 0.0872],\n", + " [ 0.0551, 0.0697],\n", + " [ 0.0494, 0.0631],\n", + " [ 0.0715, 0.1054],\n", + " [-0.0108, 0.1196],\n", + " [ 0.0299, 0.0603],\n", + " [ 0.0239, 0.0684],\n", + " [ 0.0194, 0.0501],\n", + " [ 0.0075, 0.0995],\n", + " [ 0.0670, 0.0818],\n", + " [ 0.0594, 0.0578],\n", + " [ 0.0174, 0.0901],\n", + " [ 0.0020, 0.0933],\n", + " [ 0.0479, 0.0772],\n", + " [ 0.0612, 0.0842],\n", + " [ 0.0027, 0.1050],\n", + " [ 0.0487, 0.0947],\n", + " [ 0.0326, 0.0844],\n", + " [ 0.0397, 0.0907],\n", + " [ 0.0308, 0.0724],\n", + " [ 0.0506, 0.0829],\n", + " [ 0.0544, 0.0757],\n", + " [ 0.0558, 0.0805],\n", + " [ 0.0114, 0.0966],\n", + " [ 0.0361, 0.0870],\n", + " [ 0.0213, 0.0906],\n", + " [ 0.0905, 0.0480],\n", + " [ 0.0082, 0.0884],\n", + " [ 0.0314, 0.0645],\n", + " [ 0.0432, 0.0466],\n", + " [ 0.0586, 0.0866],\n", + " [-0.0045, 0.1095],\n", + " [ 0.0022, 0.0987],\n", + " [ 0.0414, 0.0694],\n", + " [ 0.0769, 0.1061],\n", + " [ 0.0336, 0.0895],\n", + " [ 0.0678, 0.0643],\n", + " [ 0.0106, 0.0814],\n", + " [ 0.0381, 0.0939],\n", + " [ 0.0455, 0.0872],\n", + " [ 0.0064, 0.0452],\n", + " [ 0.0548, 0.0828],\n", + " [ 0.0405, 0.0589],\n", + " [ 0.0530, 0.0502],\n", + " [ 0.0582, 0.0994],\n", + " [ 0.0433, 0.0711],\n", + " [ 0.0754, 0.0575],\n", + " [ 0.0006, 0.1162],\n", + " [ 0.0466, 0.0540],\n", + " [ 0.0253, 0.0630],\n", + " [ 0.0507, 0.0666],\n", + " [ 0.0447, 0.0542],\n", + " [ 0.0651, 0.0899]], device='cuda:0', grad_fn=)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "outputs = classifier_head(embeddings)\n", + "outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "4e076c91", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(0.6934, device='cuda:0', grad_fn=)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clas_loss = classification_criterion(outputs, labels)\n", + "clas_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "423f1f54", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "87.67748260498047" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "emb_running_loss += emb_loss.item() * len(images)\n", + "emb_running_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "846b1c0d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "44.377403259277344" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clas_running_loss += clas_loss.item() * len(images)\n", + "clas_running_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "8f2a3fb1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "29" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "_, preds = torch.max(outputs, 1)\n", + "correct_predictions += torch.sum(preds == labels.data).item()\n", + "total_samples += len(images)\n", + "correct_predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "448d3126", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch , Batch 1/813, Embedding training loss: 1.3700, Classification training loss: 0.6934\n" + ] + } + ], + "source": [ + "print(f'Epoch , Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_running_loss/total_samples):.4f}, Classification training loss: {(clas_running_loss/total_samples):.4f}')" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fac26663", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(2.0634, device='cuda:0', grad_fn=)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_loss = emb_loss + clas_loss\n", + "total_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "ef1ceb73", + "metadata": {}, + "outputs": [], + "source": [ + "embedding_optimizer.zero_grad()\n", + "classifier_optimizer.zero_grad()\n", + "total_loss.backward()\n", + "embedding_optimizer.step()\n", + "classifier_optimizer.step()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "4f2b2b3a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[[ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " ...,\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", + "\n", + " [[ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " ...,\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", + "\n", + " [[ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " ...,\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", + "\n", + "\n", + " [[[ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " ...,\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", + "\n", + " [[ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " ...,\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", + "\n", + " [[ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " ...,\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", + "\n", + "\n", + " [[[ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " ...,\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", + "\n", + " [[ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " ...,\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", + "\n", + " [[ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " ...,\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + " [[[ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " ...,\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", + " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", + "\n", + " [[ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " ...,\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", + " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", + "\n", + " [[ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " ...,\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", + " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", + "\n", + "\n", + " [[[ 2.2318, 1.5468, 1.5297, ..., 2.2318, 2.2318, 2.2318],\n", + " [ 2.2318, 1.5297, 1.5297, ..., 0.8447, 0.8618, 0.8276],\n", + " [ 2.2318, 1.5297, 1.5297, ..., 0.8961, 0.9303, 0.8961],\n", + " ...,\n", + " [ 1.1015, 1.1529, 1.1529, ..., 1.4783, 1.4783, 2.2318],\n", + " [ 1.1187, 1.1187, 1.1358, ..., 1.4612, 1.4612, 2.2318],\n", + " [ 2.2318, 2.2318, 2.2318, ..., 1.4269, 1.4269, 2.2318]],\n", + "\n", + " [[ 2.4111, 0.9230, 0.9055, ..., 2.4111, 2.4111, 2.4111],\n", + " [ 2.4111, 0.9055, 0.9055, ..., -0.0574, -0.0224, 0.0301],\n", + " [ 2.4111, 0.9055, 0.9055, ..., 0.0126, 0.0126, 0.1001],\n", + " ...,\n", + " [ 0.1001, 0.1702, 0.1702, ..., 0.5553, 0.5553, 2.4111],\n", + " [ 0.1352, 0.1352, 0.1352, ..., 0.5378, 0.5378, 2.4111],\n", + " [ 2.4111, 2.4111, 2.4111, ..., 0.5203, 0.5203, 2.4111]],\n", + "\n", + " [[ 2.6226, 1.1411, 1.1237, ..., 2.6226, 2.6226, 2.6226],\n", + " [ 2.6226, 1.1237, 1.1237, ..., 0.1651, 0.1999, 0.1999],\n", + " [ 2.6226, 1.1237, 1.1237, ..., 0.2348, 0.2348, 0.2696],\n", + " ...,\n", + " [ 0.2173, 0.2696, 0.2696, ..., 0.7402, 0.7402, 2.6226],\n", + " [ 0.2348, 0.2348, 0.2522, ..., 0.7402, 0.7402, 2.6226],\n", + " [ 2.6226, 2.6226, 2.6226, ..., 0.7228, 0.7228, 2.6226]]],\n", + "\n", + "\n", + " [[[ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", + " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", + " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", + " ...,\n", + " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", + " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", + " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777]],\n", + "\n", + " [[ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", + " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", + " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", + " ...,\n", + " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", + " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", + " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535]],\n", + "\n", + " [[ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", + " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", + " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", + " ...,\n", + " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", + " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", + " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657]]]],\n", + " device='cuda:0')\n", + "tensor([1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1,\n", + " 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0,\n", + " 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1], device='cuda:0')\n" + ] + } + ], + "source": [ + "for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + " if i == 0:\n", + " break\n", + "\n", + "print(images)\n", + "print(labels)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7064b1d3", + "metadata": {}, + "outputs": [], + "source": [ + "def train_nets(\n", + " embedding_net, classifier_net, \n", + " train_loader, val_loader, \n", + " embedding_crit, classifier_crit, \n", + " embedding_opt, classifier_opt, \n", + " scheduler,\n", + " epochs, \n", + " device):\n", + " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", + " \n", + " print(\"\\n--- Training Networks ---\")\n", + "\n", + " # metric logging intialisation\n", + " best_val_ROC_AUC = -1.0\n", + " emb_train_loss_log = []\n", + " clas_train_loss_log = []\n", + " train_accuracy_log = []\n", + " emb_val_loss_log = []\n", + " clas_val_loss_log = []\n", + " val_accuracy_log = []\n", + " val_ROC_AUC_log = []\n", + " \n", + " for epoch in range(1, epochs + 1):\n", + " embedding_net.train()\n", + " classifier_net.train()\n", + " emb_running_loss = 0.0\n", + " clas_running_loss = 0.0\n", + " correct_predictions = 0\n", + " total_samples = 0\n", + "\n", + " print(f\"\\n==== Training Epoch {epoch} ====\")\n", + "\n", + " # --- Training phase ----\n", + "\n", + " for i, (images, labels) in enumerate(train_loader):\n", + " images, labels = images.to(device), labels.to(device)\n", + " #print(i)\n", + "\n", + " # ---- Embedding model training ----\n", + " \n", + " \n", + " # Generate embeddings\n", + " embeddings = embedding_net(images)\n", + " \n", + " # Calculate Triplet Loss using Batch-Hard mining\n", + " emb_loss = embedding_crit(embeddings, labels)\n", + " \n", + " # ---- Classification model training ----\n", + " \n", + " \n", + " # Classify\n", + " outputs = classifier_net(embeddings)\n", + " clas_loss = classifier_crit(outputs, labels)\n", + "\n", + " # Statistics\n", + " emb_running_loss += emb_loss.item() * len(images)\n", + " clas_running_loss += clas_loss.item() * len(images)\n", + " _, preds = torch.max(outputs, 1)\n", + " correct_predictions += torch.sum(preds == labels.data).item()\n", + " total_samples += len(images)\n", + "\n", + " if (i + 1) % 50 == 0:\n", + " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_running_loss/total_samples):.4f}, Classification training loss: {(clas_running_loss/total_samples):.4f}')\n", + " #print(clas_loss)\n", + "\n", + " total_loss = emb_loss + clas_loss\n", + "\n", + " embedding_opt.zero_grad()\n", + " classifier_opt.zero_grad()\n", + " total_loss.backward()\n", + " embedding_opt.step()\n", + " classifier_opt.step()\n", + "\n", + " # embedding training epoch loss\n", + " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", + " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", + "\n", + " # classification training epoch loss\n", + " clas_epoch_loss = clas_running_loss / total_samples\n", + " epoch_acc = correct_predictions / total_samples\n", + " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", + " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", + "\n", + " # ---- Evaluation phase ----\n", + "\n", + " print(\"--- Validation phase ---\")\n", + " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", + " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", + " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", + " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", + " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", + "\n", + " # metric logging for plotting\n", + " emb_train_loss_log.append(emb_epoch_loss)\n", + " clas_train_loss_log.append(clas_epoch_loss)\n", + " train_accuracy_log.append(epoch_acc)\n", + " emb_val_loss_log.append(val_emb_loss)\n", + " clas_val_loss_log.append(val_clas_loss)\n", + " val_accuracy_log.append(epoch_val_accuracy)\n", + " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", + "\n", + " scheduler.step(epoch_val_ROC_AUC)\n", + "\n", + " # save best model based on ROC AUC\n", + " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", + " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", + " best_val_ROC_AUC = epoch_val_ROC_AUC\n", + " # Save model checkpoint\n", + " print(\"Saving best model...\")\n", + " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", + " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", + "\n", + "\n", + " print(\"Network training complete.\")\n", + "\n", + " # Graphical display of metric logs\n", + " plot_logs(\n", + " emb_train_loss_log, \n", + " clas_train_loss_log,\n", + " train_accuracy_log,\n", + " emb_val_loss_log,\n", + " clas_val_loss_log,\n", + " val_accuracy_log,\n", + " val_ROC_AUC_log,\n", + " epochs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4f83545", + "metadata": {}, + "outputs": [], + "source": [ + "# Evaluation\n", + "test_dataset = SkinDataset(DATA_ROOT, test_samples, transform=None)\n", + "val_loader = DataLoader(test_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=0)\n", + "evaluate_model(embedding_net, classifier_head, val_loader, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "686dccd5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3313" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "512*6+241" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "9ba440ec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3313" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(val_dataset)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.7" } }, "nbformat": 4, From 1c9b13c0e6f766b1e7d4fbe1f959e5a02c618155 Mon Sep 17 00:00:00 2001 From: Melissa Maillot <71195815+MelMaillot@users.noreply.github.com> Date: Fri, 7 Nov 2025 03:11:25 +1000 Subject: [PATCH 05/15] A start on the readme file. Contains most of the content appart for the results --- recognition/Siamese_Network_MAILLOT/README.md | 108 ++++++++++++++++++ 1 file changed, 108 insertions(+) diff --git a/recognition/Siamese_Network_MAILLOT/README.md b/recognition/Siamese_Network_MAILLOT/README.md index e69de29bb..3bc1adf9e 100644 --- a/recognition/Siamese_Network_MAILLOT/README.md +++ b/recognition/Siamese_Network_MAILLOT/README.md @@ -0,0 +1,108 @@ +# Siamese network for the ISIC 2020 Kaggle Challenge classification + +Melissa Maillot - s4851573 + +## Problem + +### Data + +The ISIC 2020 Kaggle Challenge is a classification problem where skin lesions need to be classified between melonoma and normal. The dataset contains 33126 images. The dataset has severe class imbalance with only 584 melonoma samples and 32542 normal samples. + +### Siamese networks + +We implement a siamese network with triplet loss to attempt to solve this issue. + +Siamese networks are a type of metric learning model, that aims to compare the similarity of samples. Siamese networks learns to distinguish samples from different classes by using a twin network with equal weights. Both samples are passed in the network which extracts their features, and the distance between extracted embedding vectors are compared. + +In the case of classification, the training of the siamese networks aims at distinguishing the different classes in the embedding dimension, such that a classifier can be trained on the embeddings. The siamese is used as a feature extractor that maximises the embedding distnaces between classes such that the classifier may easily distinguish classes in this high dimensional space. + +Two types of loss are usually used for training a siamese network: contrastive lost and triplet loss. In this implementation, we use triplet loss. Triplet loss compares the distance between embedings of sample of the same class and a sample from another class. + +## Implementation + +### Model + +The implemented neural network has two parts: a feature extractor and a classification head. + +The feature extratctor architecture is a ResNet50 model (not pre-trained) from the PyTorch library [[1](#references)], with the last layer modified to change the extractor head and embedding dimension. As stated above, triplet loss was used. + +The classificaiton head is just a single layer perceptron with an output dimension of two for the two classes. Cross entropy loss was used as the loss function for the classifier head. + +### Metrics + +Several metrics will be used to understand the model's performance. + +First, classification accuracy will be used to get a general idea of the model's performance. However this metric isn't ideal to understand the full performance of the classifier, as the heavy data imbalance makes in unrealiable if the datasubset being considered is not balanced. + +Then, we will consider the area under the reciever operating characteristic curve (ROC-AUC). It helps us understand how well the model finds true positives compared to false positives, which can help us better understand whether classifier detects melanoma and whether it incorrectly classifies benign as malignant. + +Also, accorrding to [[2](#references)][[3](#references)][[4](#references)], ROC-AUC is not always ideal for binary classification, especially in our case with high imbalance in the dataset. One of the main issue is that ROC-AUC dose not allow us to correctly gauge the importance of false negatives. However, false negatives are extremely important in this context: an undetected melanoma can evolve into a life-threatening condition. As such false negatives are much more worrying than false positives. Since ROC-AUC fails to totally capture their importance, we will also be considering the area under the precision-recall curve (AUPRC), also called the average precision (AP) score. The precision-recall curve plots the precision (`tp/(tp+fp)`) against the recall (`tp/(tp+fn)`). The recall thus includes the much needed information on false negatives into the metric and can help us gauge whether the model could miss malignant cases. The AP score is implemented in `scikit-learn` [[5](#references)]. + +### File structure + +#### Data downloading and storage + +The data used in this project is the preprocessed ISIC 2020 dataset available [here](https://www.kaggle.com/datasets/nischaydnk/isic-2020-jpg-256x256-resized/data). In this dataset, the images have been resized to `256x256`. The metadata files only contains the images labels, image names and patient IDs. + +To run the code in this repository, you need to download the dataset from the above kaggle link to the machine that will run the code. Ideally, the downloaded materials should be placed in their own folder. The data needs to be reorganised to fit the following structure: +``` +your-data-folder-name/ +├── train-metadata.csv +└── image/ + ├── ISIC_0015719.jpg + ├── ISIC_0052212.jpg + └── ... +``` +This `your-data-folder-name` folder can be placed anywhere in the machine, so long as the path to the folder is passed to the `DATA_ROOT` hyperparameter. The parameter is currently set such that if the folder is named `data`, it should be placed in this location after cloning the repository: +``` +PatternAnalysis-2025/recognition/Siamese_Network_Maillot/ +│ +├── readme_figures/ +│ └── ... +│ +├── dataset.py +├── modules.py +├── predict.py +├── train.py +├── README.md +│ +└── data/ + ├── train-metadata.csv + └── image/ + ├── ISIC_0015719.jpg + ├── ISIC_0052212.jpg + └── ... +``` +#### Code files + +`dataset.py` contains all the classes required for data manipulation and data loading. This class handles making a 80/10/10 train/validation/test split of the data. It also oversamples the minority class for the training set, such that the training set is balanced. At runtime, the training data will be augmented with rotations, flips and colour jitters. The validation and testing set are not oversampled nor augmented. + +`modules.py` contains the neural network architectures and the triplet loss function implementation. + +`train.py` contains the main training loop and it's helper functions. The training loop will save the best model as well as the metric plots to the data location (for ease of ignoring with git if needed, this does not affect the dataloading). + +`predict.py` contains code to evaluate the model on the test split of the dataset. + +### Python and dependencies + +This project uses Python VERRRRRRR + +Additonally, the following packages are required in the following versions: + +## Results + +## Improvements + +This model is far from optimal. The number of false negatives is still much to high. This is an issue as melanoma can evolve into life-threatening conditions if not treated early. In that sense, this current model is unrealiable for unseen data. Several points of improvement may include: +- Training on a larger subset of the data: most of the data is currently not used in training as the computing power to train on the full dataset was not available (training times were too long) +- Changing the triplet loss for batch hard mining triplet loss. [[6](#references)] suggests that batch hard mining is a more efficient way to train the model, as it only uses hard triplets to calculate the loss. Implimenting this loss was attempted but unsuccessful: the model did not learn, it is unknown where the issue stemmed from and there was not enough time to troubleshoot the issue +- More extensive hyper-parameter tuning and more exploration of different augmentation techiniques +- Experimenting with the model architecture + +## References +[1] resnet50. Available at: https://docs.pytorch.org/vision/main/models/generated/torchvision.models.resnet50.html +[2] The relationship between Precision-Recall and ROC curves. Available at: https://dl.acm.org/doi/10.1145/1143844.1143874 +[3] Imbalanced Data? Stop Using ROC-AUC and Use AUPRC Instead. Available at: https://towardsdatascience.com/imbalanced-data-stop-using-roc-auc-and-use-auprc-instead-46af4910a494/ +[4] ROC AUC vs Precision-Recall for Imbalanced Data. Available at: https://machinelearningmastery.com/roc-auc-vs-precision-recall-for-imbalanced-data/ +[5] `average_precision_score`. Available at: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score +[6] In Defense of the Triplet Loss for Person Re-Identification. Available at: https://arxiv.org/pdf/1703.07737 \ No newline at end of file From 1e09855c8705bc40dda8dbef56720e4665cec1ab Mon Sep 17 00:00:00 2001 From: Mel Date: Fri, 7 Nov 2025 03:33:28 +1000 Subject: [PATCH 06/15] More model running with outputs in the notebook. New hyperparameter setting, results are mildly better --- .../WIP_notebook.ipynb | 526 +++--------------- 1 file changed, 67 insertions(+), 459 deletions(-) diff --git a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb index 6dc22eb04..f7f4654a2 100644 --- a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb +++ b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "ee6c4813", "metadata": {}, "outputs": [], @@ -57,7 +57,7 @@ "EMBEDDING_DIM = 128\n", "MARGIN = 1.0\n", "#BATCH_SIZE = 16\n", - "NUM_EPOCHS = 20\n", + "NUM_EPOCHS = 30\n", "LEARNING_RATE = 1e-4\n", "\n", "# Hyperparameters prompt 1\n", @@ -69,7 +69,7 @@ "#EMBEDDING_DIM = 128\n", "#MARGIN = 1.0 # Triplet Loss margin\n", "#LEARNING_RATE = 1e-4\n", - "NUM_EPOCHS = 20 # Training epochs for the Siamese Network\n", + "#NUM_EPOCHS = 20 # Training epochs for the Siamese Network\n", "#NUM_EPOCHS_CLASSIFIER = 10 # Training epochs for the final classifier" ] }, @@ -382,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "d324fd98", "metadata": {}, "outputs": [], @@ -436,7 +436,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "a5701bdd", "metadata": {}, "outputs": [], @@ -1412,146 +1412,9 @@ ] }, { - "cell_type": "code", - "execution_count": 12, + "cell_type": "markdown", "id": "407883a9", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "--- Training Networks ---\n", - "\n", - "==== Training Epoch 1 ====\n", - "Epoch 1/7, Batch 200/1627, Embedding training loss: 1.1077\n", - "Epoch 1/7, Batch 400/1627, Embedding training loss: 0.9941\n", - "Epoch 1/7, Batch 600/1627, Embedding training loss: 0.9646\n", - "Epoch 1/7, Batch 800/1627, Embedding training loss: 1.0336\n", - "Epoch 1/7, Batch 1000/1627, Embedding training loss: 1.0110\n", - "Epoch 1/7, Batch 1200/1627, Embedding training loss: 1.0264\n", - "Epoch 1/7, Batch 1400/1627, Embedding training loss: 1.0536\n", - "Epoch 1/7, Batch 1600/1627, Embedding training loss: 1.0086\n", - "Epoch 1 finished. \n", - "Average Training Embedding Loss: 1.0397\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9755\n", - "\n", - "==== Training Epoch 2 ====\n", - "Epoch 2/7, Batch 200/1627, Embedding training loss: 0.9523\n", - "Epoch 2/7, Batch 400/1627, Embedding training loss: 0.9580\n", - "Epoch 2/7, Batch 600/1627, Embedding training loss: 1.0062\n", - "Epoch 2/7, Batch 800/1627, Embedding training loss: 0.9781\n", - "Epoch 2/7, Batch 1000/1627, Embedding training loss: 1.1699\n", - "Epoch 2/7, Batch 1200/1627, Embedding training loss: 0.9580\n", - "Epoch 2/7, Batch 1400/1627, Embedding training loss: 0.9493\n", - "Epoch 2/7, Batch 1600/1627, Embedding training loss: 1.0381\n", - "Epoch 2 finished. \n", - "Average Training Embedding Loss: 1.0099\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.3642\n", - "\n", - "==== Training Epoch 3 ====\n", - "Epoch 3/7, Batch 200/1627, Embedding training loss: 1.0660\n", - "Epoch 3/7, Batch 400/1627, Embedding training loss: 1.1197\n", - "Epoch 3/7, Batch 600/1627, Embedding training loss: 0.9338\n", - "Epoch 3/7, Batch 800/1627, Embedding training loss: 1.1626\n", - "Epoch 3/7, Batch 1000/1627, Embedding training loss: 1.0175\n", - "Epoch 3/7, Batch 1200/1627, Embedding training loss: 1.0149\n", - "Epoch 3/7, Batch 1400/1627, Embedding training loss: 0.9300\n", - "Epoch 3/7, Batch 1600/1627, Embedding training loss: 0.9963\n", - "Epoch 3 finished. \n", - "Average Training Embedding Loss: 1.0153\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.5090\n", - "\n", - "==== Training Epoch 4 ====\n", - "Epoch 4/7, Batch 200/1627, Embedding training loss: 0.8523\n", - "Epoch 4/7, Batch 400/1627, Embedding training loss: 0.8468\n", - "Epoch 4/7, Batch 600/1627, Embedding training loss: 1.0609\n", - "Epoch 4/7, Batch 800/1627, Embedding training loss: 1.0725\n", - "Epoch 4/7, Batch 1000/1627, Embedding training loss: 1.0503\n", - "Epoch 4/7, Batch 1200/1627, Embedding training loss: 1.0391\n", - "Epoch 4/7, Batch 1400/1627, Embedding training loss: 0.8811\n", - "Epoch 4/7, Batch 1600/1627, Embedding training loss: 1.0558\n", - "Epoch 4 finished. \n", - "Average Training Embedding Loss: 1.0154\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.4742\n", - "\n", - "==== Training Epoch 5 ====\n", - "Epoch 5/7, Batch 200/1627, Embedding training loss: 1.1731\n", - "Epoch 5/7, Batch 400/1627, Embedding training loss: 0.8620\n", - "Epoch 5/7, Batch 600/1627, Embedding training loss: 0.9244\n", - "Epoch 5/7, Batch 800/1627, Embedding training loss: 1.0486\n", - "Epoch 5/7, Batch 1000/1627, Embedding training loss: 1.1810\n", - "Epoch 5/7, Batch 1200/1627, Embedding training loss: 0.8051\n", - "Epoch 5/7, Batch 1400/1627, Embedding training loss: 0.8796\n", - "Epoch 5/7, Batch 1600/1627, Embedding training loss: 1.0491\n", - "Epoch 5 finished. \n", - "Average Training Embedding Loss: 1.0106\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.5228\n", - "\n", - "==== Training Epoch 6 ====\n", - "Epoch 6/7, Batch 200/1627, Embedding training loss: 0.9905\n", - "Epoch 6/7, Batch 400/1627, Embedding training loss: 0.8799\n", - "Epoch 6/7, Batch 600/1627, Embedding training loss: 1.0066\n", - "Epoch 6/7, Batch 800/1627, Embedding training loss: 1.0047\n", - "Epoch 6/7, Batch 1000/1627, Embedding training loss: 1.0231\n", - "Epoch 6/7, Batch 1200/1627, Embedding training loss: 1.0180\n", - "Epoch 6/7, Batch 1400/1627, Embedding training loss: 0.9366\n", - "Epoch 6/7, Batch 1600/1627, Embedding training loss: 0.8862\n", - "Epoch 6 finished. \n", - "Average Training Embedding Loss: 1.0099\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.3839\n", - "\n", - "==== Training Epoch 7 ====\n", - "Epoch 7/7, Batch 200/1627, Embedding training loss: 1.0897\n", - "Epoch 7/7, Batch 400/1627, Embedding training loss: 0.9968\n", - "Epoch 7/7, Batch 600/1627, Embedding training loss: 0.9966\n", - "Epoch 7/7, Batch 800/1627, Embedding training loss: 1.0164\n", - "Epoch 7/7, Batch 1000/1627, Embedding training loss: 1.1047\n", - "Epoch 7/7, Batch 1200/1627, Embedding training loss: 1.2214\n", - "Epoch 7/7, Batch 1400/1627, Embedding training loss: 1.0261\n", - "Epoch 7/7, Batch 1600/1627, Embedding training loss: 0.6800\n", - "Epoch 7 finished. \n", - "Average Training Embedding Loss: 1.0097\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.3572\n", - "Network training complete.\n" - ] - }, - { - "ename": "ValueError", - "evalue": "x and y must have same first dimension, but have shapes (7,) and (0,)", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[12]\u001b[39m\u001b[32m, line 33\u001b[39m\n\u001b[32m 30\u001b[39m classification_criterion = nn.CrossEntropyLoss().to(device)\n\u001b[32m 31\u001b[39m \u001b[38;5;66;03m#classifier_optimizer = optim.Adam(classifier_head.parameters(), lr=LEARNING_RATE)# * 5) # Faster learning rate for small head\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m33\u001b[39m \u001b[43mtrain_nets\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 34\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_loader\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 35\u001b[39m \u001b[43m \u001b[49m\u001b[43membedding_net\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43membedding_optimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 36\u001b[39m \u001b[43m \u001b[49m\u001b[43mtriplet_criterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclassification_criterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 37\u001b[39m \u001b[43m \u001b[49m\u001b[43membedding_scheduler\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 38\u001b[39m \u001b[43m \u001b[49m\u001b[32;43m7\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 39\u001b[39m \u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[11]\u001b[39m\u001b[32m, line 114\u001b[39m, in \u001b[36mtrain_nets\u001b[39m\u001b[34m(train_loader, val_loader, embedding_net, embedding_opt, embedding_crit, classifier_crit, scheduler, epochs, device)\u001b[39m\n\u001b[32m 111\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mNetwork training complete.\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 113\u001b[39m \u001b[38;5;66;03m# Graphical display of metric logs\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m114\u001b[39m \u001b[43mplot_logs\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 115\u001b[39m \u001b[43m \u001b[49m\u001b[43memb_train_loss_log\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 116\u001b[39m \u001b[43m \u001b[49m\u001b[43mclas_train_loss_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 117\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_accuracy_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 118\u001b[39m \u001b[43m \u001b[49m\u001b[43memb_val_loss_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 119\u001b[39m \u001b[43m \u001b[49m\u001b[43mclas_val_loss_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 120\u001b[39m \u001b[43m \u001b[49m\u001b[43mval_accuracy_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 121\u001b[39m \u001b[43m \u001b[49m\u001b[43mval_ROC_AUC_log\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 122\u001b[39m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[10]\u001b[39m\u001b[32m, line 22\u001b[39m, in \u001b[36mplot_logs\u001b[39m\u001b[34m(emb_train_loss_log, clas_train_loss_log, train_accuracy_log, emb_val_loss_log, clas_val_loss_log, val_accuracy_log, val_ROC_AUC_log, epochs)\u001b[39m\n\u001b[32m 19\u001b[39m plt.legend()\n\u001b[32m 21\u001b[39m plt.subplot(\u001b[32m2\u001b[39m, \u001b[32m2\u001b[39m, \u001b[32m2\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m22\u001b[39m \u001b[43mplt\u001b[49m\u001b[43m.\u001b[49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclas_train_loss_log\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mTrain Loss\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolor\u001b[49m\u001b[43m=\u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43m#F05039\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 23\u001b[39m plt.plot(\u001b[38;5;28mrange\u001b[39m(epochs), clas_val_loss_log, label=\u001b[33m'\u001b[39m\u001b[33mValidation Loss\u001b[39m\u001b[33m'\u001b[39m, color=\u001b[33m'\u001b[39m\u001b[33m#3D65A5\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m 24\u001b[39m plt.title(\u001b[33m'\u001b[39m\u001b[33mClassification Loss over Epochs\u001b[39m\u001b[33m'\u001b[39m)\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\matplotlib\\pyplot.py:3838\u001b[39m, in \u001b[36mplot\u001b[39m\u001b[34m(scalex, scaley, data, *args, **kwargs)\u001b[39m\n\u001b[32m 3830\u001b[39m \u001b[38;5;129m@_copy_docstring_and_deprecators\u001b[39m(Axes.plot)\n\u001b[32m 3831\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mplot\u001b[39m(\n\u001b[32m 3832\u001b[39m *args: \u001b[38;5;28mfloat\u001b[39m | ArrayLike | \u001b[38;5;28mstr\u001b[39m,\n\u001b[32m (...)\u001b[39m\u001b[32m 3836\u001b[39m **kwargs,\n\u001b[32m 3837\u001b[39m ) -> \u001b[38;5;28mlist\u001b[39m[Line2D]:\n\u001b[32m-> \u001b[39m\u001b[32m3838\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgca\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 3839\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3840\u001b[39m \u001b[43m \u001b[49m\u001b[43mscalex\u001b[49m\u001b[43m=\u001b[49m\u001b[43mscalex\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3841\u001b[39m \u001b[43m \u001b[49m\u001b[43mscaley\u001b[49m\u001b[43m=\u001b[49m\u001b[43mscaley\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3842\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mdata\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m}\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m{\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3843\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3844\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\matplotlib\\axes\\_axes.py:1777\u001b[39m, in \u001b[36mAxes.plot\u001b[39m\u001b[34m(self, scalex, scaley, data, *args, **kwargs)\u001b[39m\n\u001b[32m 1534\u001b[39m \u001b[38;5;250m\u001b[39m\u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 1535\u001b[39m \u001b[33;03mPlot y versus x as lines and/or markers.\u001b[39;00m\n\u001b[32m 1536\u001b[39m \n\u001b[32m (...)\u001b[39m\u001b[32m 1774\u001b[39m \u001b[33;03m(``'green'``) or hex strings (``'#008000'``).\u001b[39;00m\n\u001b[32m 1775\u001b[39m \u001b[33;03m\"\"\"\u001b[39;00m\n\u001b[32m 1776\u001b[39m kwargs = cbook.normalize_kwargs(kwargs, mlines.Line2D)\n\u001b[32m-> \u001b[39m\u001b[32m1777\u001b[39m lines = [*\u001b[38;5;28mself\u001b[39m._get_lines(\u001b[38;5;28mself\u001b[39m, *args, data=data, **kwargs)]\n\u001b[32m 1778\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m line \u001b[38;5;129;01min\u001b[39;00m lines:\n\u001b[32m 1779\u001b[39m \u001b[38;5;28mself\u001b[39m.add_line(line)\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\matplotlib\\axes\\_base.py:297\u001b[39m, in \u001b[36m_process_plot_var_args.__call__\u001b[39m\u001b[34m(self, axes, data, return_kwargs, *args, **kwargs)\u001b[39m\n\u001b[32m 295\u001b[39m this += args[\u001b[32m0\u001b[39m],\n\u001b[32m 296\u001b[39m args = args[\u001b[32m1\u001b[39m:]\n\u001b[32m--> \u001b[39m\u001b[32m297\u001b[39m \u001b[38;5;28;01myield from\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_plot_args\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 298\u001b[39m \u001b[43m \u001b[49m\u001b[43maxes\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mthis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mambiguous_fmt_datakey\u001b[49m\u001b[43m=\u001b[49m\u001b[43mambiguous_fmt_datakey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 299\u001b[39m \u001b[43m \u001b[49m\u001b[43mreturn_kwargs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mreturn_kwargs\u001b[49m\n\u001b[32m 300\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\matplotlib\\axes\\_base.py:494\u001b[39m, in \u001b[36m_process_plot_var_args._plot_args\u001b[39m\u001b[34m(self, axes, tup, kwargs, return_kwargs, ambiguous_fmt_datakey)\u001b[39m\n\u001b[32m 491\u001b[39m axes.yaxis.update_units(y)\n\u001b[32m 493\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m x.shape[\u001b[32m0\u001b[39m] != y.shape[\u001b[32m0\u001b[39m]:\n\u001b[32m--> \u001b[39m\u001b[32m494\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mx and y must have same first dimension, but \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 495\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mhave shapes \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mx.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m and \u001b[39m\u001b[38;5;132;01m{\u001b[39;00my.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 496\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m x.ndim > \u001b[32m2\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m y.ndim > \u001b[32m2\u001b[39m:\n\u001b[32m 497\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mx and y can be no greater than 2D, but have \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 498\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mshapes \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mx.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m and \u001b[39m\u001b[38;5;132;01m{\u001b[39;00my.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", - "\u001b[31mValueError\u001b[39m: x and y must have same first dimension, but have shapes (7,) and (0,)" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", "\n", @@ -1595,11 +1458,9 @@ ] }, { - "cell_type": "code", - "execution_count": 10, + "cell_type": "markdown", "id": "efdf32b3", "metadata": {}, - "outputs": [], "source": [ "def train_epoch(model, dataloader, criterion, optimizer):\n", " model.train()\n", @@ -1626,7 +1487,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "81422af3", "metadata": {}, "outputs": [], @@ -1644,7 +1505,7 @@ " for i, (img_a, img_p, img_n, label_a) in enumerate(dataloader):\n", "\n", " #print(\"yo\", i+1)\n", - " img_a, img_p, img_n = img_a.to(device), img_p.to(device), img_n.to(device)\n", + " img_a, img_p, img_n, label_a = img_a.to(device), img_p.to(device), img_n.to(device), label_a.to(device)\n", "\n", " optimizer.zero_grad()\n", " \n", @@ -1676,7 +1537,7 @@ " probs = torch.softmax(out_a, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", " all_labels.extend(label_a.cpu().numpy())\n", " all_predictions.extend(preds.cpu().numpy())\n", - " all_probs.extend(probs.cpu().numpy())\n", + " all_probs.extend(probs.cpu().detach().numpy())\n", "\n", " #print(\"on est passe\")\n", "\n", @@ -1697,7 +1558,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "0c915db6", "metadata": {}, "outputs": [], @@ -1722,7 +1583,7 @@ " for _, (img_a, img_p, img_n, label_a) in enumerate(dataloader):\n", "\n", " #print(\"yo\", i+1)\n", - " img_a, img_p, img_n = img_a.to(device), img_p.to(device), img_n.to(device)\n", + " img_a, img_p, img_n, label_a = img_a.to(device), img_p.to(device), img_n.to(device), label_a.to(device)\n", " \n", " # Get embeddings\n", " emb_a = model(img_a)\n", @@ -1746,7 +1607,7 @@ " probs = torch.softmax(out_a, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", " all_labels.extend(label_a.cpu().numpy())\n", " all_predictions.extend(preds.cpu().numpy())\n", - " all_probs.extend(probs.cpu().numpy())\n", + " all_probs.extend(probs.cpu().detach().numpy())\n", "\n", " emb_epoch_loss = emb_running_loss / total_samples\n", " class_epoch_loss = class_running_loss / total_samples\n", @@ -1830,314 +1691,61 @@ "output_type": "stream", "text": [ "Using device: cuda\n", - "Number of normal samples in training data subset: 10449\n", - "Number of melanoma samples in training data subset: 10377\n", + "Number of normal samples in training data subset: 1097\n", + "Number of melanoma samples in training data subset: 986\n", "\n", "--- Starting Training ---\n", - "ici\n", - "Batch 50/651, Embedding training loss: 1.0433\n", - "Batch 100/651, Embedding training loss: 0.9702\n", - "Batch 150/651, Embedding training loss: 0.9370\n", - "Batch 200/651, Embedding training loss: 0.9464\n", - "Batch 250/651, Embedding training loss: 0.9019\n", - "Batch 300/651, Embedding training loss: 1.0698\n", - "Batch 350/651, Embedding training loss: 1.0377\n", - "Batch 400/651, Embedding training loss: 0.9379\n", - "Batch 450/651, Embedding training loss: 0.9327\n", - "Batch 500/651, Embedding training loss: 1.0038\n", - "Batch 550/651, Embedding training loss: 1.0248\n", - "Batch 600/651, Embedding training loss: 0.9805\n", - "Batch 650/651, Embedding training loss: 0.9933\n", - "Epoch 1/20: | Train Loss: 1.0052 | Test Accuracy: 75.43% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.9941\n", - "Batch 100/651, Embedding training loss: 1.0060\n", - "Batch 150/651, Embedding training loss: 0.9492\n", - "Batch 200/651, Embedding training loss: 0.9877\n", - "Batch 250/651, Embedding training loss: 1.1558\n", - "Batch 300/651, Embedding training loss: 0.8516\n", - "Batch 350/651, Embedding training loss: 0.9338\n", - "Batch 400/651, Embedding training loss: 1.0534\n", - "Batch 450/651, Embedding training loss: 1.0293\n", - "Batch 500/651, Embedding training loss: 1.1635\n", - "Batch 550/651, Embedding training loss: 0.9603\n", - "Batch 600/651, Embedding training loss: 1.0423\n", - "Batch 650/651, Embedding training loss: 0.9754\n", - "Epoch 2/20: | Train Loss: 0.9991 | Test Accuracy: 74.74% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 1.0142\n", - "Batch 100/651, Embedding training loss: 1.0199\n", - "Batch 150/651, Embedding training loss: 0.7551\n", - "Batch 200/651, Embedding training loss: 1.0831\n", - "Batch 250/651, Embedding training loss: 0.8270\n", - "Batch 300/651, Embedding training loss: 0.8556\n", - "Batch 350/651, Embedding training loss: 0.8047\n", - "Batch 400/651, Embedding training loss: 0.9194\n", - "Batch 450/651, Embedding training loss: 0.8726\n", - "Batch 500/651, Embedding training loss: 1.0849\n", - "Batch 550/651, Embedding training loss: 0.9971\n", - "Batch 600/651, Embedding training loss: 0.6280\n", - "Batch 650/651, Embedding training loss: 0.6716\n", - "Epoch 3/20: | Train Loss: 0.9360 | Test Accuracy: 62.39% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.7339\n", - "Batch 100/651, Embedding training loss: 0.9860\n", - "Batch 150/651, Embedding training loss: 0.9713\n", - "Batch 200/651, Embedding training loss: 0.7792\n", - "Batch 250/651, Embedding training loss: 0.7460\n", - "Batch 300/651, Embedding training loss: 0.7465\n", - "Batch 350/651, Embedding training loss: 0.7027\n", - "Batch 400/651, Embedding training loss: 1.0381\n", - "Batch 450/651, Embedding training loss: 1.0057\n", - "Batch 500/651, Embedding training loss: 0.9338\n", - "Batch 550/651, Embedding training loss: 0.9754\n", - "Batch 600/651, Embedding training loss: 1.0169\n", - "Batch 650/651, Embedding training loss: 1.0257\n", - "Epoch 4/20: | Train Loss: 0.9090 | Test Accuracy: 57.17% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.8254\n", - "Batch 100/651, Embedding training loss: 0.7525\n", - "Batch 150/651, Embedding training loss: 1.0936\n", - "Batch 200/651, Embedding training loss: 0.7159\n", - "Batch 250/651, Embedding training loss: 0.9777\n", - "Batch 300/651, Embedding training loss: 1.0795\n", - "Batch 350/651, Embedding training loss: 0.6378\n", - "Batch 400/651, Embedding training loss: 0.9069\n", - "Batch 450/651, Embedding training loss: 0.6548\n", - "Batch 500/651, Embedding training loss: 1.0464\n", - "Batch 550/651, Embedding training loss: 0.9372\n", - "Batch 600/651, Embedding training loss: 0.9257\n", - "Batch 650/651, Embedding training loss: 0.6733\n", - "Epoch 5/20: | Train Loss: 0.8947 | Test Accuracy: 68.04% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.6817\n", - "Batch 100/651, Embedding training loss: 1.0117\n", - "Batch 150/651, Embedding training loss: 0.7493\n", - "Batch 200/651, Embedding training loss: 0.6283\n", - "Batch 250/651, Embedding training loss: 0.8177\n", - "Batch 300/651, Embedding training loss: 0.9655\n", - "Batch 350/651, Embedding training loss: 0.9284\n", - "Batch 400/651, Embedding training loss: 0.8662\n", - "Batch 450/651, Embedding training loss: 0.8936\n", - "Batch 500/651, Embedding training loss: 0.9434\n", - "Batch 550/651, Embedding training loss: 0.9057\n", - "Batch 600/651, Embedding training loss: 0.9025\n", - "Batch 650/651, Embedding training loss: 0.7762\n", - "Epoch 6/20: | Train Loss: 0.8613 | Test Accuracy: 68.25% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.7871\n", - "Batch 100/651, Embedding training loss: 0.8442\n", - "Batch 150/651, Embedding training loss: 0.9525\n", - "Batch 200/651, Embedding training loss: 0.9400\n", - "Batch 250/651, Embedding training loss: 0.9582\n", - "Batch 300/651, Embedding training loss: 0.8132\n", - "Batch 350/651, Embedding training loss: 0.7650\n", - "Batch 400/651, Embedding training loss: 1.0256\n", - "Batch 450/651, Embedding training loss: 0.8973\n", - "Batch 500/651, Embedding training loss: 0.8756\n", - "Batch 550/651, Embedding training loss: 1.0567\n", - "Batch 600/651, Embedding training loss: 0.6825\n", - "Batch 650/651, Embedding training loss: 0.7767\n", - "Epoch 7/20: | Train Loss: 0.8357 | Test Accuracy: 66.41% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.8511\n", - "Batch 100/651, Embedding training loss: 1.0448\n", - "Batch 150/651, Embedding training loss: 0.7865\n", - "Batch 200/651, Embedding training loss: 0.8027\n", - "Batch 250/651, Embedding training loss: 1.0012\n", - "Batch 300/651, Embedding training loss: 0.8322\n", - "Batch 350/651, Embedding training loss: 0.6300\n", - "Batch 400/651, Embedding training loss: 0.6963\n", - "Batch 450/651, Embedding training loss: 0.6841\n", - "Batch 500/651, Embedding training loss: 0.6477\n", - "Batch 550/651, Embedding training loss: 0.9165\n", - "Batch 600/651, Embedding training loss: 0.4800\n", - "Batch 650/651, Embedding training loss: 0.8581\n", - "Epoch 8/20: | Train Loss: 0.8226 | Test Accuracy: 69.48% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 1.0554\n", - "Batch 100/651, Embedding training loss: 0.7125\n", - "Batch 150/651, Embedding training loss: 0.6354\n", - "Batch 200/651, Embedding training loss: 0.9703\n", - "Batch 250/651, Embedding training loss: 0.8246\n", - "Batch 300/651, Embedding training loss: 0.6126\n", - "Batch 350/651, Embedding training loss: 0.9045\n", - "Batch 400/651, Embedding training loss: 0.7606\n", - "Batch 450/651, Embedding training loss: 0.8058\n", - "Batch 500/651, Embedding training loss: 0.8063\n", - "Batch 550/651, Embedding training loss: 1.1629\n", - "Batch 600/651, Embedding training loss: 0.7261\n", - "Batch 650/651, Embedding training loss: 0.6894\n", - "Epoch 9/20: | Train Loss: 0.7947 | Test Accuracy: 70.57% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.8882\n", - "Batch 100/651, Embedding training loss: 0.7655\n", - "Batch 150/651, Embedding training loss: 0.6591\n", - "Batch 200/651, Embedding training loss: 0.7328\n", - "Batch 250/651, Embedding training loss: 0.7122\n", - "Batch 300/651, Embedding training loss: 0.7530\n", - "Batch 350/651, Embedding training loss: 0.6809\n", - "Batch 400/651, Embedding training loss: 0.6446\n", - "Batch 450/651, Embedding training loss: 0.7506\n", - "Batch 500/651, Embedding training loss: 0.8855\n", - "Batch 550/651, Embedding training loss: 0.8850\n", - "Batch 600/651, Embedding training loss: 0.7865\n", - "Batch 650/651, Embedding training loss: 1.0001\n", - "Epoch 10/20: | Train Loss: 0.7864 | Test Accuracy: 69.15% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.7409\n", - "Batch 100/651, Embedding training loss: 0.7351\n", - "Batch 150/651, Embedding training loss: 0.8151\n", - "Batch 200/651, Embedding training loss: 0.7091\n", - "Batch 250/651, Embedding training loss: 0.8767\n", - "Batch 300/651, Embedding training loss: 0.7184\n", - "Batch 350/651, Embedding training loss: 0.6895\n", - "Batch 400/651, Embedding training loss: 1.0286\n", - "Batch 450/651, Embedding training loss: 0.6628\n", - "Batch 500/651, Embedding training loss: 0.9155\n", - "Batch 550/651, Embedding training loss: 0.7207\n", - "Batch 600/651, Embedding training loss: 0.9877\n", - "Batch 650/651, Embedding training loss: 0.7152\n", - "Epoch 11/20: | Train Loss: 0.7688 | Test Accuracy: 70.48% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.8553\n", - "Batch 100/651, Embedding training loss: 0.5856\n", - "Batch 150/651, Embedding training loss: 0.4819\n", - "Batch 200/651, Embedding training loss: 0.8288\n", - "Batch 250/651, Embedding training loss: 0.7959\n", - "Batch 300/651, Embedding training loss: 0.5806\n", - "Batch 350/651, Embedding training loss: 0.9526\n", - "Batch 400/651, Embedding training loss: 0.9973\n", - "Batch 450/651, Embedding training loss: 0.6407\n", - "Batch 500/651, Embedding training loss: 0.7815\n", - "Batch 550/651, Embedding training loss: 0.6542\n", - "Batch 600/651, Embedding training loss: 0.8451\n", - "Batch 650/651, Embedding training loss: 0.8146\n", - "Epoch 12/20: | Train Loss: 0.7585 | Test Accuracy: 74.19% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.8715\n", - "Batch 100/651, Embedding training loss: 0.7170\n", - "Batch 150/651, Embedding training loss: 0.8354\n", - "Batch 200/651, Embedding training loss: 1.0796\n", - "Batch 250/651, Embedding training loss: 0.7759\n", - "Batch 300/651, Embedding training loss: 0.6996\n", - "Batch 350/651, Embedding training loss: 0.5027\n", - "Batch 400/651, Embedding training loss: 0.8089\n", - "Batch 450/651, Embedding training loss: 0.7181\n", - "Batch 500/651, Embedding training loss: 0.7225\n", - "Batch 550/651, Embedding training loss: 0.6912\n", - "Batch 600/651, Embedding training loss: 0.6742\n", - "Batch 650/651, Embedding training loss: 0.5089\n", - "Epoch 13/20: | Train Loss: 0.7376 | Test Accuracy: 75.04% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.5103\n", - "Batch 100/651, Embedding training loss: 0.7334\n", - "Batch 150/651, Embedding training loss: 0.6978\n", - "Batch 200/651, Embedding training loss: 0.7160\n", - "Batch 250/651, Embedding training loss: 0.7911\n", - "Batch 300/651, Embedding training loss: 0.9181\n", - "Batch 350/651, Embedding training loss: 0.5724\n", - "Batch 400/651, Embedding training loss: 0.4896\n", - "Batch 450/651, Embedding training loss: 0.7514\n", - "Batch 500/651, Embedding training loss: 0.6514\n", - "Batch 550/651, Embedding training loss: 0.6107\n", - "Batch 600/651, Embedding training loss: 0.6755\n", - "Batch 650/651, Embedding training loss: 0.7436\n", - "Epoch 14/20: | Train Loss: 0.7089 | Test Accuracy: 77.33% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.6720\n", - "Batch 100/651, Embedding training loss: 0.8618\n", - "Batch 150/651, Embedding training loss: 0.6614\n", - "Batch 200/651, Embedding training loss: 0.7899\n", - "Batch 250/651, Embedding training loss: 0.6115\n", - "Batch 300/651, Embedding training loss: 0.6203\n", - "Batch 350/651, Embedding training loss: 0.5912\n", - "Batch 400/651, Embedding training loss: 0.5593\n", - "Batch 450/651, Embedding training loss: 0.6098\n", - "Batch 500/651, Embedding training loss: 0.7040\n", - "Batch 550/651, Embedding training loss: 0.6199\n", - "Batch 600/651, Embedding training loss: 0.6339\n", - "Batch 650/651, Embedding training loss: 0.4569\n", - "Epoch 15/20: | Train Loss: 0.6828 | Test Accuracy: 77.36% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.5399\n", - "Batch 100/651, Embedding training loss: 0.5418\n", - "Batch 150/651, Embedding training loss: 1.1730\n", - "Batch 200/651, Embedding training loss: 0.7682\n", - "Batch 250/651, Embedding training loss: 0.5464\n", - "Batch 300/651, Embedding training loss: 0.7292\n", - "Batch 350/651, Embedding training loss: 0.6012\n", - "Batch 400/651, Embedding training loss: 0.8411\n", - "Batch 450/651, Embedding training loss: 0.7385\n", - "Batch 500/651, Embedding training loss: 0.7424\n", - "Batch 550/651, Embedding training loss: 0.7475\n", - "Batch 600/651, Embedding training loss: 0.6158\n", - "Batch 650/651, Embedding training loss: 0.8267\n", - "Epoch 16/20: | Train Loss: 0.6583 | Test Accuracy: 82.16% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.6916\n", - "Batch 100/651, Embedding training loss: 0.6542\n", - "Batch 150/651, Embedding training loss: 0.7077\n", - "Batch 200/651, Embedding training loss: 0.7248\n", - "Batch 250/651, Embedding training loss: 0.5061\n", - "Batch 300/651, Embedding training loss: 0.3420\n", - "Batch 350/651, Embedding training loss: 0.4552\n", - "Batch 400/651, Embedding training loss: 0.7127\n", - "Batch 450/651, Embedding training loss: 0.4834\n", - "Batch 500/651, Embedding training loss: 0.4366\n", - "Batch 550/651, Embedding training loss: 0.6212\n", - "Batch 600/651, Embedding training loss: 0.6471\n", - "Batch 650/651, Embedding training loss: 0.5009\n", - "Epoch 17/20: | Train Loss: 0.6363 | Test Accuracy: 76.43% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.6375\n", - "Batch 100/651, Embedding training loss: 0.4805\n", - "Batch 150/651, Embedding training loss: 0.6764\n", - "Batch 200/651, Embedding training loss: 0.7939\n", - "Batch 250/651, Embedding training loss: 0.4486\n", - "Batch 300/651, Embedding training loss: 0.6346\n", - "Batch 350/651, Embedding training loss: 0.5725\n", - "Batch 400/651, Embedding training loss: 0.6113\n", - "Batch 450/651, Embedding training loss: 0.6076\n", - "Batch 500/651, Embedding training loss: 0.7885\n", - "Batch 550/651, Embedding training loss: 0.7369\n", - "Batch 600/651, Embedding training loss: 0.6087\n", - "Batch 650/651, Embedding training loss: 0.4526\n", - "Epoch 18/20: | Train Loss: 0.6053 | Test Accuracy: 80.14% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 0.6482\n", - "Batch 100/651, Embedding training loss: 0.5784\n", - "Batch 150/651, Embedding training loss: 0.7174\n", - "Batch 200/651, Embedding training loss: 0.5573\n", - "Batch 250/651, Embedding training loss: 0.7378\n", - "Batch 300/651, Embedding training loss: 0.5528\n", - "Batch 350/651, Embedding training loss: 0.5017\n", - "Batch 400/651, Embedding training loss: 0.3908\n", - "Batch 450/651, Embedding training loss: 0.5170\n", - "Batch 500/651, Embedding training loss: 0.4614\n", - "Batch 550/651, Embedding training loss: 0.4944\n", - "Batch 600/651, Embedding training loss: 0.5471\n", - "Batch 650/651, Embedding training loss: 0.5593\n", - "Epoch 19/20: | Train Loss: 0.5877 | Test Accuracy: 80.89% (3313 samples)\n", - "ici\n", - "Batch 50/651, Embedding training loss: 1.0096\n", - "Batch 100/651, Embedding training loss: 0.3865\n", - "Batch 150/651, Embedding training loss: 0.6385\n", - "Batch 200/651, Embedding training loss: 0.6560\n", - "Batch 250/651, Embedding training loss: 0.4407\n", - "Batch 300/651, Embedding training loss: 0.4531\n", - "Batch 350/651, Embedding training loss: 0.3855\n", - "Batch 400/651, Embedding training loss: 0.4408\n", - "Batch 450/651, Embedding training loss: 0.5973\n", - "Batch 500/651, Embedding training loss: 0.4610\n", - "Batch 550/651, Embedding training loss: 0.4459\n", - "Batch 600/651, Embedding training loss: 0.6158\n", - "Batch 650/651, Embedding training loss: 0.5478\n", - "Epoch 20/20: | Train Loss: 0.5822 | Test Accuracy: 80.50% (3313 samples)\n", "\n", - "--- Training Finished ---\n", - "Best Test Accuracy: 0.00%\n", - "Goal: Achieve accuracy around 0.8 (80.00%) using Triplet Loss for robust melanoma classification.\n" + "==== Training Epoch 1 ====\n", + "Batch 50/66, Embedding training loss: 1.0915, Classification training loss: 0.7137\n", + "Epoch 1 training finished.\n", + "Average Training Embedding Loss: 1.0358\n", + "Average Training Classification Loss: 0.6949\n", + "Training Classification Accuracy: 0.4911\n", + "Training ROC AUC: 0.5108\n", + "Training Average Precision Score: 0.4972\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.9838\n", + "Average Validation Classification Loss: 0.7001\n", + "Validation Classification Accuracy: 0.2137\n", + "Validation ROC AUC: 0.6267\n", + "Validation Average Precision Score: 0.0302\n", + "Previous best average precision score: -1.0000\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 2 ====\n", + "Batch 50/66, Embedding training loss: 1.0475, Classification training loss: 0.6907\n", + "Epoch 2 training finished.\n", + "Average Training Embedding Loss: 1.0173\n", + "Average Training Classification Loss: 0.6911\n", + "Training Classification Accuracy: 0.5218\n", + "Training ROC AUC: 0.5505\n", + "Training Average Precision Score: 0.5243\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.9868\n", + "Average Validation Classification Loss: 0.6956\n", + "Validation Classification Accuracy: 0.5895\n", + "Validation ROC AUC: 0.6639\n", + "Validation Average Precision Score: 0.0316\n", + "Previous best average precision score: 0.0302\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 3 ====\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[16]\u001b[39m\u001b[32m, line 49\u001b[39m\n\u001b[32m 46\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[32m1\u001b[39m, \u001b[32m7\u001b[39m + \u001b[32m1\u001b[39m):\u001b[38;5;66;03m#NUM_EPOCHS\u001b[39;00m\n\u001b[32m 47\u001b[39m \u001b[38;5;66;03m# Train\u001b[39;00m\n\u001b[32m 48\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33m==== Training Epoch \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m ====\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m49\u001b[39m emb_train_loss, class_train_loss, train_acc, train_auc, train_aps = \u001b[43mtrain_epoch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclassifier_crit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduler\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 51\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mEpoch \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m training finished.\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 52\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mAverage Training Embedding Loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00memb_train_loss\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 33\u001b[39m, in \u001b[36mtrain_epoch\u001b[39m\u001b[34m(model, dataloader, criterion, classification_crit, optimizer, scheduler, device)\u001b[39m\n\u001b[32m 30\u001b[39m loss = emb_loss + class_loss\n\u001b[32m 32\u001b[39m \u001b[38;5;66;03m#print(\"ya\", loss.item())\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m33\u001b[39m \u001b[43mloss\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 34\u001b[39m optimizer.step()\n\u001b[32m 36\u001b[39m \u001b[38;5;66;03m#total_loss += loss.item() * img_a.size(0)\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\_tensor.py:647\u001b[39m, in \u001b[36mTensor.backward\u001b[39m\u001b[34m(self, gradient, retain_graph, create_graph, inputs)\u001b[39m\n\u001b[32m 637\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 638\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[32m 639\u001b[39m Tensor.backward,\n\u001b[32m 640\u001b[39m (\u001b[38;5;28mself\u001b[39m,),\n\u001b[32m (...)\u001b[39m\u001b[32m 645\u001b[39m inputs=inputs,\n\u001b[32m 646\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m647\u001b[39m \u001b[43mtorch\u001b[49m\u001b[43m.\u001b[49m\u001b[43mautograd\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 648\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m=\u001b[49m\u001b[43minputs\u001b[49m\n\u001b[32m 649\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\autograd\\__init__.py:354\u001b[39m, in \u001b[36mbackward\u001b[39m\u001b[34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[39m\n\u001b[32m 349\u001b[39m retain_graph = create_graph\n\u001b[32m 351\u001b[39m \u001b[38;5;66;03m# The reason we repeat the same comment below is that\u001b[39;00m\n\u001b[32m 352\u001b[39m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[32m 353\u001b[39m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m354\u001b[39m \u001b[43m_engine_run_backward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 355\u001b[39m \u001b[43m \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 356\u001b[39m \u001b[43m \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 357\u001b[39m \u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 358\u001b[39m \u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 359\u001b[39m \u001b[43m \u001b[49m\u001b[43minputs_tuple\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 360\u001b[39m \u001b[43m \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 361\u001b[39m \u001b[43m \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 362\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\autograd\\graph.py:829\u001b[39m, in \u001b[36m_engine_run_backward\u001b[39m\u001b[34m(t_outputs, *args, **kwargs)\u001b[39m\n\u001b[32m 827\u001b[39m unregister_hooks = _register_logging_hooks_on_whole_graph(t_outputs)\n\u001b[32m 828\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m829\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mVariable\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_execution_engine\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[32m 830\u001b[39m \u001b[43m \u001b[49m\u001b[43mt_outputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\n\u001b[32m 831\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# Calls into the C++ engine to run the backward pass\u001b[39;00m\n\u001b[32m 832\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[32m 833\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m attach_logging_hooks:\n", + "\u001b[31mKeyboardInterrupt\u001b[39m: " ] } ], @@ -2145,7 +1753,7 @@ "print(f\"Using device: {device}\")\n", "\n", "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", - "train_samples = train_samples.sample(frac=0.4).reset_index(drop=True)\n", + "train_samples = train_samples.sample(frac=0.4).reset_index(drop=True)#frac=0.4\n", "print(f\"Number of normal samples in training data subset: {train_samples[train_samples[\"target\"]== 0].shape[0]}\")\n", "print(f\"Number of melanoma samples in training data subset: {train_samples[train_samples[\"target\"]== 1].shape[0]}\")\n", "\n", @@ -2187,7 +1795,7 @@ "val_AP_score_log = []\n", "\n", "print(\"\\n--- Starting Training ---\")\n", - "for epoch in range(1, NUM_EPOCHS + 1):\n", + "for epoch in range(1, NUM_EPOCHS + 1):#NUM_EPOCHS\n", " # Train\n", " print(f\"\\n==== Training Epoch {epoch} ====\")\n", " emb_train_loss, class_train_loss, train_acc, train_auc, train_aps = train_epoch(model, train_loader, criterion, classifier_crit, optimizer, scheduler, device)\n", From 343500c69c0b618bb9ef85099147389d3d8da4bd Mon Sep 17 00:00:00 2001 From: Mel Date: Fri, 7 Nov 2025 03:37:09 +1000 Subject: [PATCH 07/15] FOLLOW UP FROM PREVIOUS COMMIT: not all changes were saved for the previous commit, previous commit message applies to this commit as well --- .../WIP_notebook.ipynb | 2203 ++++++++++++++++- 1 file changed, 2153 insertions(+), 50 deletions(-) diff --git a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb index f7f4654a2..cf4742d89 100644 --- a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb +++ b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "ee6c4813", "metadata": {}, "outputs": [], @@ -16,7 +16,7 @@ "import numpy as np\n", "import pandas as pd\n", "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score\n", + "from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix\n", "import random\n", "#import itertools\n", "from PIL import Image\n", @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "id": "ee90ac6d", "metadata": {}, "outputs": [], @@ -382,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 34, "id": "d324fd98", "metadata": {}, "outputs": [], @@ -400,10 +400,10 @@ " self.fc_out = nn.Sequential(\n", " nn.Linear(2048, 512),\n", " nn.ReLU(inplace=True),\n", - " nn.Dropout(0.5),\n", + " nn.Dropout(0.3), # 0.5\n", " nn.Linear(512, 256),\n", " nn.ReLU(inplace=True),\n", - " nn.Dropout(0.5),\n", + " nn.Dropout(0.3), # 0.5\n", " nn.Linear(256, out_dim)\n", " )\n", " \n", @@ -1487,7 +1487,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 8, "id": "81422af3", "metadata": {}, "outputs": [], @@ -1558,7 +1558,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "id": "0c915db6", "metadata": {}, "outputs": [], @@ -1682,7 +1682,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "196c123e", "metadata": {}, "outputs": [ @@ -1691,61 +1691,843 @@ "output_type": "stream", "text": [ "Using device: cuda\n", - "Number of normal samples in training data subset: 1097\n", - "Number of melanoma samples in training data subset: 986\n", + "Number of normal samples in training data subset: 10449\n", + "Number of melanoma samples in training data subset: 10377\n", "\n", "--- Starting Training ---\n", "\n", "==== Training Epoch 1 ====\n", - "Batch 50/66, Embedding training loss: 1.0915, Classification training loss: 0.7137\n", + "Batch 50/651, Embedding training loss: 0.9814, Classification training loss: 0.6888\n", + "Batch 100/651, Embedding training loss: 1.0644, Classification training loss: 0.6908\n", + "Batch 150/651, Embedding training loss: 1.0644, Classification training loss: 0.6908\n", + "Batch 200/651, Embedding training loss: 1.0753, Classification training loss: 0.6987\n", + "Batch 250/651, Embedding training loss: 0.9547, Classification training loss: 0.7016\n", + "Batch 300/651, Embedding training loss: 0.9953, Classification training loss: 0.6815\n", + "Batch 350/651, Embedding training loss: 0.9992, Classification training loss: 0.6962\n", + "Batch 400/651, Embedding training loss: 0.8949, Classification training loss: 0.7003\n", + "Batch 450/651, Embedding training loss: 0.9874, Classification training loss: 0.6795\n", + "Batch 500/651, Embedding training loss: 1.0594, Classification training loss: 0.6797\n", + "Batch 550/651, Embedding training loss: 1.0385, Classification training loss: 0.6858\n", + "Batch 600/651, Embedding training loss: 0.9611, Classification training loss: 0.6901\n", + "Batch 650/651, Embedding training loss: 0.9665, Classification training loss: 0.6771\n", "Epoch 1 training finished.\n", - "Average Training Embedding Loss: 1.0358\n", - "Average Training Classification Loss: 0.6949\n", - "Training Classification Accuracy: 0.4911\n", - "Training ROC AUC: 0.5108\n", - "Training Average Precision Score: 0.4972\n", + "Average Training Embedding Loss: 1.0055\n", + "Average Training Classification Loss: 0.6911\n", + "Training Classification Accuracy: 0.5297\n", + "Training ROC AUC: 0.5388\n", + "Training Average Precision Score: 0.5309\n", "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9838\n", - "Average Validation Classification Loss: 0.7001\n", - "Validation Classification Accuracy: 0.2137\n", - "Validation ROC AUC: 0.6267\n", - "Validation Average Precision Score: 0.0302\n", + "Average Validation Embedding Loss: 0.9993\n", + "Average Validation Classification Loss: 0.6660\n", + "Validation Classification Accuracy: 0.8814\n", + "Validation ROC AUC: 0.6740\n", + "Validation Average Precision Score: 0.0284\n", "Previous best average precision score: -1.0000\n", "Saving best model...\n", "\n", "==== Training Epoch 2 ====\n", - "Batch 50/66, Embedding training loss: 1.0475, Classification training loss: 0.6907\n", + "Batch 50/651, Embedding training loss: 1.1315, Classification training loss: 0.6789\n", + "Batch 100/651, Embedding training loss: 0.9980, Classification training loss: 0.6748\n", + "Batch 150/651, Embedding training loss: 1.0653, Classification training loss: 0.6961\n", + "Batch 200/651, Embedding training loss: 0.9769, Classification training loss: 0.6992\n", + "Batch 250/651, Embedding training loss: 0.9894, Classification training loss: 0.6914\n", + "Batch 300/651, Embedding training loss: 0.9823, Classification training loss: 0.6658\n", + "Batch 350/651, Embedding training loss: 0.9492, Classification training loss: 0.6686\n", + "Batch 400/651, Embedding training loss: 1.0491, Classification training loss: 0.6668\n", + "Batch 450/651, Embedding training loss: 1.0348, Classification training loss: 0.6774\n", + "Batch 500/651, Embedding training loss: 0.8528, Classification training loss: 0.6251\n", + "Batch 550/651, Embedding training loss: 0.9261, Classification training loss: 0.5777\n", + "Batch 600/651, Embedding training loss: 1.1215, Classification training loss: 0.5965\n", + "Batch 650/651, Embedding training loss: 0.7349, Classification training loss: 0.5941\n", "Epoch 2 training finished.\n", - "Average Training Embedding Loss: 1.0173\n", - "Average Training Classification Loss: 0.6911\n", - "Training Classification Accuracy: 0.5218\n", - "Training ROC AUC: 0.5505\n", - "Training Average Precision Score: 0.5243\n", + "Average Training Embedding Loss: 0.9783\n", + "Average Training Classification Loss: 0.6629\n", + "Training Classification Accuracy: 0.6066\n", + "Training ROC AUC: 0.6555\n", + "Training Average Precision Score: 0.6138\n", "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9868\n", - "Average Validation Classification Loss: 0.6956\n", - "Validation Classification Accuracy: 0.5895\n", - "Validation ROC AUC: 0.6639\n", - "Validation Average Precision Score: 0.0316\n", - "Previous best average precision score: 0.0302\n", + "Average Validation Embedding Loss: 1.0773\n", + "Average Validation Classification Loss: 0.5449\n", + "Validation Classification Accuracy: 0.7027\n", + "Validation ROC AUC: 0.7736\n", + "Validation Average Precision Score: 0.0677\n", + "Previous best average precision score: 0.0284\n", "Saving best model...\n", "\n", - "==== Training Epoch 3 ====\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[16]\u001b[39m\u001b[32m, line 49\u001b[39m\n\u001b[32m 46\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[32m1\u001b[39m, \u001b[32m7\u001b[39m + \u001b[32m1\u001b[39m):\u001b[38;5;66;03m#NUM_EPOCHS\u001b[39;00m\n\u001b[32m 47\u001b[39m \u001b[38;5;66;03m# Train\u001b[39;00m\n\u001b[32m 48\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33m==== Training Epoch \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m ====\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m49\u001b[39m emb_train_loss, class_train_loss, train_acc, train_auc, train_aps = \u001b[43mtrain_epoch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mclassifier_crit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscheduler\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 51\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mEpoch \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m training finished.\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 52\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mAverage Training Embedding Loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00memb_train_loss\u001b[38;5;132;01m:\u001b[39;00m\u001b[33m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 33\u001b[39m, in \u001b[36mtrain_epoch\u001b[39m\u001b[34m(model, dataloader, criterion, classification_crit, optimizer, scheduler, device)\u001b[39m\n\u001b[32m 30\u001b[39m loss = emb_loss + class_loss\n\u001b[32m 32\u001b[39m \u001b[38;5;66;03m#print(\"ya\", loss.item())\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m33\u001b[39m \u001b[43mloss\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 34\u001b[39m optimizer.step()\n\u001b[32m 36\u001b[39m \u001b[38;5;66;03m#total_loss += loss.item() * img_a.size(0)\u001b[39;00m\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\_tensor.py:647\u001b[39m, in \u001b[36mTensor.backward\u001b[39m\u001b[34m(self, gradient, retain_graph, create_graph, inputs)\u001b[39m\n\u001b[32m 637\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 638\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[32m 639\u001b[39m Tensor.backward,\n\u001b[32m 640\u001b[39m (\u001b[38;5;28mself\u001b[39m,),\n\u001b[32m (...)\u001b[39m\u001b[32m 645\u001b[39m inputs=inputs,\n\u001b[32m 646\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m647\u001b[39m \u001b[43mtorch\u001b[49m\u001b[43m.\u001b[49m\u001b[43mautograd\u001b[49m\u001b[43m.\u001b[49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 648\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m=\u001b[49m\u001b[43minputs\u001b[49m\n\u001b[32m 649\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\autograd\\__init__.py:354\u001b[39m, in \u001b[36mbackward\u001b[39m\u001b[34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[39m\n\u001b[32m 349\u001b[39m retain_graph = create_graph\n\u001b[32m 351\u001b[39m \u001b[38;5;66;03m# The reason we repeat the same comment below is that\u001b[39;00m\n\u001b[32m 352\u001b[39m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[32m 353\u001b[39m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m354\u001b[39m \u001b[43m_engine_run_backward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 355\u001b[39m \u001b[43m \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 356\u001b[39m \u001b[43m \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 357\u001b[39m \u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 358\u001b[39m \u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 359\u001b[39m \u001b[43m \u001b[49m\u001b[43minputs_tuple\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 360\u001b[39m \u001b[43m \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 361\u001b[39m \u001b[43m \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 362\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\autograd\\graph.py:829\u001b[39m, in \u001b[36m_engine_run_backward\u001b[39m\u001b[34m(t_outputs, *args, **kwargs)\u001b[39m\n\u001b[32m 827\u001b[39m unregister_hooks = _register_logging_hooks_on_whole_graph(t_outputs)\n\u001b[32m 828\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m829\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mVariable\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_execution_engine\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[32m 830\u001b[39m \u001b[43m \u001b[49m\u001b[43mt_outputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\n\u001b[32m 831\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# Calls into the C++ engine to run the backward pass\u001b[39;00m\n\u001b[32m 832\u001b[39m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[32m 833\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m attach_logging_hooks:\n", - "\u001b[31mKeyboardInterrupt\u001b[39m: " + "==== Training Epoch 3 ====\n", + "Batch 50/651, Embedding training loss: 0.9967, Classification training loss: 0.5309\n", + "Batch 100/651, Embedding training loss: 0.8354, Classification training loss: 0.5939\n", + "Batch 150/651, Embedding training loss: 0.8093, Classification training loss: 0.5489\n", + "Batch 200/651, Embedding training loss: 0.8093, Classification training loss: 0.5426\n", + "Batch 250/651, Embedding training loss: 0.8013, Classification training loss: 0.5755\n", + "Batch 300/651, Embedding training loss: 1.0536, Classification training loss: 0.6235\n", + "Batch 350/651, Embedding training loss: 0.8784, Classification training loss: 0.5977\n", + "Batch 400/651, Embedding training loss: 0.8154, Classification training loss: 0.6752\n", + "Batch 450/651, Embedding training loss: 0.9902, Classification training loss: 0.7035\n", + "Batch 500/651, Embedding training loss: 0.7335, Classification training loss: 0.5614\n", + "Batch 550/651, Embedding training loss: 0.8467, Classification training loss: 0.5633\n", + "Batch 600/651, Embedding training loss: 1.1874, Classification training loss: 0.5183\n", + "Batch 650/651, Embedding training loss: 0.7564, Classification training loss: 0.5242\n", + "Epoch 3 training finished.\n", + "Average Training Embedding Loss: 0.9039\n", + "Average Training Classification Loss: 0.5891\n", + "Training Classification Accuracy: 0.6968\n", + "Training ROC AUC: 0.7406\n", + "Training Average Precision Score: 0.6752\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.0705\n", + "Average Validation Classification Loss: 0.5104\n", + "Validation Classification Accuracy: 0.6973\n", + "Validation ROC AUC: 0.7933\n", + "Validation Average Precision Score: 0.0471\n", + "\n", + "==== Training Epoch 4 ====\n", + "Batch 50/651, Embedding training loss: 0.7895, Classification training loss: 0.5246\n", + "Batch 100/651, Embedding training loss: 0.9032, Classification training loss: 0.5530\n", + "Batch 150/651, Embedding training loss: 0.6660, Classification training loss: 0.5359\n", + "Batch 200/651, Embedding training loss: 0.5997, Classification training loss: 0.5260\n", + "Batch 250/651, Embedding training loss: 0.9593, Classification training loss: 0.5289\n", + "Batch 300/651, Embedding training loss: 1.0562, Classification training loss: 0.6078\n", + "Batch 350/651, Embedding training loss: 0.7136, Classification training loss: 0.5684\n", + "Batch 400/651, Embedding training loss: 1.0087, Classification training loss: 0.5611\n", + "Batch 450/651, Embedding training loss: 0.6732, Classification training loss: 0.5002\n", + "Batch 500/651, Embedding training loss: 0.9404, Classification training loss: 0.4909\n", + "Batch 550/651, Embedding training loss: 1.1808, Classification training loss: 0.6539\n", + "Batch 600/651, Embedding training loss: 1.0692, Classification training loss: 0.5513\n", + "Batch 650/651, Embedding training loss: 0.6207, Classification training loss: 0.5648\n", + "Epoch 4 training finished.\n", + "Average Training Embedding Loss: 0.8732\n", + "Average Training Classification Loss: 0.5684\n", + "Training Classification Accuracy: 0.7124\n", + "Training ROC AUC: 0.7586\n", + "Training Average Precision Score: 0.6899\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.9885\n", + "Average Validation Classification Loss: 0.4757\n", + "Validation Classification Accuracy: 0.7374\n", + "Validation ROC AUC: 0.8147\n", + "Validation Average Precision Score: 0.0506\n", + "\n", + "==== Training Epoch 5 ====\n", + "Batch 50/651, Embedding training loss: 0.8788, Classification training loss: 0.5046\n", + "Batch 100/651, Embedding training loss: 0.5758, Classification training loss: 0.5636\n", + "Batch 150/651, Embedding training loss: 0.8199, Classification training loss: 0.6014\n", + "Batch 200/651, Embedding training loss: 0.7128, Classification training loss: 0.5589\n", + "Batch 250/651, Embedding training loss: 0.5568, Classification training loss: 0.6317\n", + "Batch 300/651, Embedding training loss: 1.1061, Classification training loss: 0.5681\n", + "Batch 350/651, Embedding training loss: 0.9197, Classification training loss: 0.5215\n", + "Batch 400/651, Embedding training loss: 0.5025, Classification training loss: 0.3584\n", + "Batch 450/651, Embedding training loss: 0.9359, Classification training loss: 0.6003\n", + "Batch 500/651, Embedding training loss: 0.9530, Classification training loss: 0.4965\n", + "Batch 550/651, Embedding training loss: 0.8064, Classification training loss: 0.4985\n", + "Batch 600/651, Embedding training loss: 0.7286, Classification training loss: 0.6053\n", + "Batch 650/651, Embedding training loss: 0.9125, Classification training loss: 0.3933\n", + "Epoch 5 training finished.\n", + "Average Training Embedding Loss: 0.8519\n", + "Average Training Classification Loss: 0.5525\n", + "Training Classification Accuracy: 0.7288\n", + "Training ROC AUC: 0.7781\n", + "Training Average Precision Score: 0.7155\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.0296\n", + "Average Validation Classification Loss: 0.5072\n", + "Validation Classification Accuracy: 0.6942\n", + "Validation ROC AUC: 0.8231\n", + "Validation Average Precision Score: 0.0608\n", + "\n", + "==== Training Epoch 6 ====\n", + "Batch 50/651, Embedding training loss: 0.8554, Classification training loss: 0.5366\n", + "Batch 100/651, Embedding training loss: 0.5760, Classification training loss: 0.4187\n", + "Batch 150/651, Embedding training loss: 0.7630, Classification training loss: 0.4576\n", + "Batch 200/651, Embedding training loss: 0.7559, Classification training loss: 0.6027\n", + "Batch 250/651, Embedding training loss: 0.7760, Classification training loss: 0.4682\n", + "Batch 300/651, Embedding training loss: 1.1682, Classification training loss: 0.7009\n", + "Batch 350/651, Embedding training loss: 0.6723, Classification training loss: 0.4666\n", + "Batch 400/651, Embedding training loss: 0.6785, Classification training loss: 0.5370\n", + "Batch 450/651, Embedding training loss: 0.7802, Classification training loss: 0.4984\n", + "Batch 500/651, Embedding training loss: 0.6565, Classification training loss: 0.4798\n", + "Batch 550/651, Embedding training loss: 1.0335, Classification training loss: 0.7186\n", + "Batch 600/651, Embedding training loss: 0.9819, Classification training loss: 0.5569\n", + "Batch 650/651, Embedding training loss: 0.9631, Classification training loss: 0.5922\n", + "Epoch 6 training finished.\n", + "Average Training Embedding Loss: 0.8311\n", + "Average Training Classification Loss: 0.5390\n", + "Training Classification Accuracy: 0.7383\n", + "Training ROC AUC: 0.7872\n", + "Training Average Precision Score: 0.7226\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.9932\n", + "Average Validation Classification Loss: 0.4796\n", + "Validation Classification Accuracy: 0.7003\n", + "Validation ROC AUC: 0.8256\n", + "Validation Average Precision Score: 0.0650\n", + "\n", + "==== Training Epoch 7 ====\n", + "Batch 50/651, Embedding training loss: 0.9541, Classification training loss: 0.5492\n", + "Batch 100/651, Embedding training loss: 0.9200, Classification training loss: 0.4656\n", + "Batch 150/651, Embedding training loss: 0.8133, Classification training loss: 0.4607\n", + "Batch 200/651, Embedding training loss: 0.6303, Classification training loss: 0.4029\n", + "Batch 250/651, Embedding training loss: 0.7636, Classification training loss: 0.5112\n", + "Batch 300/651, Embedding training loss: 0.8579, Classification training loss: 0.4889\n", + "Batch 350/651, Embedding training loss: 0.7224, Classification training loss: 0.5493\n", + "Batch 400/651, Embedding training loss: 0.7694, Classification training loss: 0.5994\n", + "Batch 450/651, Embedding training loss: 0.8307, Classification training loss: 0.4854\n", + "Batch 500/651, Embedding training loss: 0.7928, Classification training loss: 0.5272\n", + "Batch 550/651, Embedding training loss: 0.8093, Classification training loss: 0.4933\n", + "Batch 600/651, Embedding training loss: 0.8663, Classification training loss: 0.4913\n", + "Batch 650/651, Embedding training loss: 0.6242, Classification training loss: 0.6574\n", + "Epoch 7 training finished.\n", + "Average Training Embedding Loss: 0.8100\n", + "Average Training Classification Loss: 0.5295\n", + "Training Classification Accuracy: 0.7459\n", + "Training ROC AUC: 0.7975\n", + "Training Average Precision Score: 0.7371\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.0355\n", + "Average Validation Classification Loss: 0.5955\n", + "Validation Classification Accuracy: 0.6049\n", + "Validation ROC AUC: 0.8286\n", + "Validation Average Precision Score: 0.0742\n", + "Previous best average precision score: 0.0677\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 8 ====\n", + "Batch 50/651, Embedding training loss: 0.8209, Classification training loss: 0.4328\n", + "Batch 100/651, Embedding training loss: 0.9602, Classification training loss: 0.4000\n", + "Batch 150/651, Embedding training loss: 0.8625, Classification training loss: 0.5563\n", + "Batch 200/651, Embedding training loss: 0.6910, Classification training loss: 0.4409\n", + "Batch 250/651, Embedding training loss: 0.6769, Classification training loss: 0.4927\n", + "Batch 300/651, Embedding training loss: 0.5518, Classification training loss: 0.4379\n", + "Batch 350/651, Embedding training loss: 0.6153, Classification training loss: 0.4274\n", + "Batch 400/651, Embedding training loss: 0.7742, Classification training loss: 0.5893\n", + "Batch 450/651, Embedding training loss: 0.6586, Classification training loss: 0.3807\n", + "Batch 500/651, Embedding training loss: 0.7780, Classification training loss: 0.5561\n", + "Batch 550/651, Embedding training loss: 0.7630, Classification training loss: 0.4247\n", + "Batch 600/651, Embedding training loss: 0.7175, Classification training loss: 0.3993\n", + "Batch 650/651, Embedding training loss: 0.9066, Classification training loss: 0.5850\n", + "Epoch 8 training finished.\n", + "Average Training Embedding Loss: 0.8014\n", + "Average Training Classification Loss: 0.5221\n", + "Training Classification Accuracy: 0.7508\n", + "Training ROC AUC: 0.8043\n", + "Training Average Precision Score: 0.7441\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.8372\n", + "Average Validation Classification Loss: 0.3982\n", + "Validation Classification Accuracy: 0.7972\n", + "Validation ROC AUC: 0.8077\n", + "Validation Average Precision Score: 0.0611\n", + "\n", + "==== Training Epoch 9 ====\n", + "Batch 50/651, Embedding training loss: 0.9895, Classification training loss: 0.7234\n", + "Batch 100/651, Embedding training loss: 0.3559, Classification training loss: 0.3481\n", + "Batch 150/651, Embedding training loss: 1.2448, Classification training loss: 0.5577\n", + "Batch 200/651, Embedding training loss: 0.8110, Classification training loss: 0.5135\n", + "Batch 250/651, Embedding training loss: 0.7580, Classification training loss: 0.4050\n", + "Batch 300/651, Embedding training loss: 0.7827, Classification training loss: 0.4640\n", + "Batch 350/651, Embedding training loss: 0.6943, Classification training loss: 0.4753\n", + "Batch 400/651, Embedding training loss: 0.8743, Classification training loss: 0.4532\n", + "Batch 450/651, Embedding training loss: 0.7248, Classification training loss: 0.5431\n", + "Batch 500/651, Embedding training loss: 0.7600, Classification training loss: 0.4946\n", + "Batch 550/651, Embedding training loss: 0.8192, Classification training loss: 0.5486\n", + "Batch 600/651, Embedding training loss: 0.8595, Classification training loss: 0.4499\n", + "Batch 650/651, Embedding training loss: 0.6718, Classification training loss: 0.5051\n", + "Epoch 9 training finished.\n", + "Average Training Embedding Loss: 0.7783\n", + "Average Training Classification Loss: 0.5118\n", + "Training Classification Accuracy: 0.7580\n", + "Training ROC AUC: 0.8105\n", + "Training Average Precision Score: 0.7500\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.8296\n", + "Average Validation Classification Loss: 0.4066\n", + "Validation Classification Accuracy: 0.7416\n", + "Validation ROC AUC: 0.8695\n", + "Validation Average Precision Score: 0.0837\n", + "Previous best average precision score: 0.0742\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 10 ====\n", + "Batch 50/651, Embedding training loss: 0.7851, Classification training loss: 0.5454\n", + "Batch 100/651, Embedding training loss: 0.9918, Classification training loss: 0.6448\n", + "Batch 150/651, Embedding training loss: 0.5441, Classification training loss: 0.4159\n", + "Batch 200/651, Embedding training loss: 0.4936, Classification training loss: 0.3717\n", + "Batch 250/651, Embedding training loss: 0.7519, Classification training loss: 0.4715\n", + "Batch 300/651, Embedding training loss: 0.7512, Classification training loss: 0.5062\n", + "Batch 350/651, Embedding training loss: 0.5844, Classification training loss: 0.3397\n", + "Batch 400/651, Embedding training loss: 0.4680, Classification training loss: 0.3441\n", + "Batch 450/651, Embedding training loss: 0.9670, Classification training loss: 0.5784\n", + "Batch 500/651, Embedding training loss: 0.5391, Classification training loss: 0.3393\n", + "Batch 550/651, Embedding training loss: 0.8944, Classification training loss: 0.5150\n", + "Batch 600/651, Embedding training loss: 0.5685, Classification training loss: 0.4592\n", + "Batch 650/651, Embedding training loss: 0.8363, Classification training loss: 0.4558\n", + "Epoch 10 training finished.\n", + "Average Training Embedding Loss: 0.7546\n", + "Average Training Classification Loss: 0.4953\n", + "Training Classification Accuracy: 0.7678\n", + "Training ROC AUC: 0.8261\n", + "Training Average Precision Score: 0.7702\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.7719\n", + "Average Validation Classification Loss: 0.3991\n", + "Validation Classification Accuracy: 0.7631\n", + "Validation ROC AUC: 0.8551\n", + "Validation Average Precision Score: 0.0973\n", + "Previous best average precision score: 0.0837\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 11 ====\n", + "Batch 50/651, Embedding training loss: 0.5281, Classification training loss: 0.4413\n", + "Batch 100/651, Embedding training loss: 0.8900, Classification training loss: 0.4385\n", + "Batch 150/651, Embedding training loss: 0.7070, Classification training loss: 0.5043\n", + "Batch 200/651, Embedding training loss: 0.4954, Classification training loss: 0.4448\n", + "Batch 250/651, Embedding training loss: 0.5553, Classification training loss: 0.2879\n", + "Batch 300/651, Embedding training loss: 0.6938, Classification training loss: 0.4412\n", + "Batch 350/651, Embedding training loss: 0.8168, Classification training loss: 0.4643\n", + "Batch 400/651, Embedding training loss: 0.7566, Classification training loss: 0.5817\n", + "Batch 450/651, Embedding training loss: 0.8015, Classification training loss: 0.5232\n", + "Batch 500/651, Embedding training loss: 0.6463, Classification training loss: 0.3524\n", + "Batch 550/651, Embedding training loss: 0.8710, Classification training loss: 0.4890\n", + "Batch 600/651, Embedding training loss: 0.7781, Classification training loss: 0.4816\n", + "Batch 650/651, Embedding training loss: 0.5553, Classification training loss: 0.3955\n", + "Epoch 11 training finished.\n", + "Average Training Embedding Loss: 0.7376\n", + "Average Training Classification Loss: 0.4859\n", + "Training Classification Accuracy: 0.7733\n", + "Training ROC AUC: 0.8368\n", + "Training Average Precision Score: 0.7894\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.7819\n", + "Average Validation Classification Loss: 0.4017\n", + "Validation Classification Accuracy: 0.7839\n", + "Validation ROC AUC: 0.8590\n", + "Validation Average Precision Score: 0.0787\n", + "\n", + "==== Training Epoch 12 ====\n", + "Batch 50/651, Embedding training loss: 0.5847, Classification training loss: 0.4041\n", + "Batch 100/651, Embedding training loss: 0.9744, Classification training loss: 0.4036\n", + "Batch 150/651, Embedding training loss: 0.6571, Classification training loss: 0.5972\n", + "Batch 200/651, Embedding training loss: 0.7979, Classification training loss: 0.5364\n", + "Batch 250/651, Embedding training loss: 0.8335, Classification training loss: 0.4855\n", + "Batch 300/651, Embedding training loss: 0.6500, Classification training loss: 0.3375\n", + "Batch 350/651, Embedding training loss: 0.7315, Classification training loss: 0.4496\n", + "Batch 400/651, Embedding training loss: 1.0514, Classification training loss: 0.5969\n", + "Batch 450/651, Embedding training loss: 0.6395, Classification training loss: 0.5005\n", + "Batch 500/651, Embedding training loss: 0.6807, Classification training loss: 0.3561\n", + "Batch 550/651, Embedding training loss: 0.6780, Classification training loss: 0.4558\n", + "Batch 600/651, Embedding training loss: 0.8741, Classification training loss: 0.5701\n", + "Batch 650/651, Embedding training loss: 0.5523, Classification training loss: 0.3818\n", + "Epoch 12 training finished.\n", + "Average Training Embedding Loss: 0.7106\n", + "Average Training Classification Loss: 0.4711\n", + "Training Classification Accuracy: 0.7828\n", + "Training ROC AUC: 0.8462\n", + "Training Average Precision Score: 0.7936\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.7466\n", + "Average Validation Classification Loss: 0.3528\n", + "Validation Classification Accuracy: 0.7842\n", + "Validation ROC AUC: 0.8740\n", + "Validation Average Precision Score: 0.1177\n", + "Previous best average precision score: 0.0973\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 13 ====\n", + "Batch 50/651, Embedding training loss: 0.8383, Classification training loss: 0.5752\n", + "Batch 100/651, Embedding training loss: 0.9829, Classification training loss: 0.7558\n", + "Batch 150/651, Embedding training loss: 0.8435, Classification training loss: 0.4918\n", + "Batch 200/651, Embedding training loss: 0.5702, Classification training loss: 0.3330\n", + "Batch 250/651, Embedding training loss: 0.6973, Classification training loss: 0.4811\n", + "Batch 300/651, Embedding training loss: 0.7610, Classification training loss: 0.3719\n", + "Batch 350/651, Embedding training loss: 0.5912, Classification training loss: 0.4802\n", + "Batch 400/651, Embedding training loss: 0.7882, Classification training loss: 0.5186\n", + "Batch 450/651, Embedding training loss: 0.9239, Classification training loss: 0.5655\n", + "Batch 500/651, Embedding training loss: 0.7098, Classification training loss: 0.4532\n", + "Batch 550/651, Embedding training loss: 0.5725, Classification training loss: 0.5216\n", + "Batch 600/651, Embedding training loss: 0.9100, Classification training loss: 0.5201\n", + "Batch 650/651, Embedding training loss: 0.6551, Classification training loss: 0.3720\n", + "Epoch 13 training finished.\n", + "Average Training Embedding Loss: 0.6991\n", + "Average Training Classification Loss: 0.4619\n", + "Training Classification Accuracy: 0.7872\n", + "Training ROC AUC: 0.8542\n", + "Training Average Precision Score: 0.8098\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.8215\n", + "Average Validation Classification Loss: 0.3910\n", + "Validation Classification Accuracy: 0.7661\n", + "Validation ROC AUC: 0.8556\n", + "Validation Average Precision Score: 0.0963\n", + "\n", + "==== Training Epoch 14 ====\n", + "Batch 50/651, Embedding training loss: 0.8417, Classification training loss: 0.4855\n", + "Batch 100/651, Embedding training loss: 0.8431, Classification training loss: 0.5281\n", + "Batch 150/651, Embedding training loss: 0.3674, Classification training loss: 0.3866\n", + "Batch 200/651, Embedding training loss: 0.6458, Classification training loss: 0.5392\n", + "Batch 250/651, Embedding training loss: 0.6582, Classification training loss: 0.3658\n", + "Batch 300/651, Embedding training loss: 0.5948, Classification training loss: 0.4075\n", + "Batch 350/651, Embedding training loss: 0.9094, Classification training loss: 0.3373\n", + "Batch 400/651, Embedding training loss: 0.6534, Classification training loss: 0.4050\n", + "Batch 450/651, Embedding training loss: 0.6752, Classification training loss: 0.4966\n", + "Batch 500/651, Embedding training loss: 0.7509, Classification training loss: 0.3899\n", + "Batch 550/651, Embedding training loss: 0.5609, Classification training loss: 0.4943\n", + "Batch 600/651, Embedding training loss: 0.7503, Classification training loss: 0.4706\n", + "Batch 650/651, Embedding training loss: 0.5930, Classification training loss: 0.3513\n", + "Epoch 14 training finished.\n", + "Average Training Embedding Loss: 0.6568\n", + "Average Training Classification Loss: 0.4406\n", + "Training Classification Accuracy: 0.8018\n", + "Training ROC AUC: 0.8677\n", + "Training Average Precision Score: 0.8223\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.7852\n", + "Average Validation Classification Loss: 0.3775\n", + "Validation Classification Accuracy: 0.7706\n", + "Validation ROC AUC: 0.8573\n", + "Validation Average Precision Score: 0.1178\n", + "Previous best average precision score: 0.1177\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 15 ====\n", + "Batch 50/651, Embedding training loss: 0.4123, Classification training loss: 0.2139\n", + "Batch 100/651, Embedding training loss: 0.6008, Classification training loss: 0.4607\n", + "Batch 150/651, Embedding training loss: 0.5672, Classification training loss: 0.3313\n", + "Batch 200/651, Embedding training loss: 0.6125, Classification training loss: 0.4773\n", + "Batch 250/651, Embedding training loss: 0.6892, Classification training loss: 0.4569\n", + "Batch 300/651, Embedding training loss: 0.6998, Classification training loss: 0.5064\n", + "Batch 350/651, Embedding training loss: 0.4068, Classification training loss: 0.2714\n", + "Batch 400/651, Embedding training loss: 0.7246, Classification training loss: 0.5506\n", + "Batch 450/651, Embedding training loss: 0.7955, Classification training loss: 0.5008\n", + "Batch 500/651, Embedding training loss: 0.5903, Classification training loss: 0.3808\n", + "Batch 550/651, Embedding training loss: 0.8702, Classification training loss: 0.5594\n", + "Batch 600/651, Embedding training loss: 0.5165, Classification training loss: 0.2941\n", + "Batch 650/651, Embedding training loss: 0.6198, Classification training loss: 0.4907\n", + "Epoch 15 training finished.\n", + "Average Training Embedding Loss: 0.6211\n", + "Average Training Classification Loss: 0.4199\n", + "Training Classification Accuracy: 0.8145\n", + "Training ROC AUC: 0.8800\n", + "Training Average Precision Score: 0.8412\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.7887\n", + "Average Validation Classification Loss: 0.4078\n", + "Validation Classification Accuracy: 0.7540\n", + "Validation ROC AUC: 0.8619\n", + "Validation Average Precision Score: 0.1007\n", + "\n", + "==== Training Epoch 16 ====\n", + "Batch 50/651, Embedding training loss: 0.6946, Classification training loss: 0.5163\n", + "Batch 100/651, Embedding training loss: 0.6499, Classification training loss: 0.4882\n", + "Batch 150/651, Embedding training loss: 0.4395, Classification training loss: 0.3323\n", + "Batch 200/651, Embedding training loss: 0.7744, Classification training loss: 0.4424\n", + "Batch 250/651, Embedding training loss: 0.5025, Classification training loss: 0.3415\n", + "Batch 300/651, Embedding training loss: 0.4859, Classification training loss: 0.3215\n", + "Batch 350/651, Embedding training loss: 0.5262, Classification training loss: 0.3886\n", + "Batch 400/651, Embedding training loss: 0.5853, Classification training loss: 0.3929\n", + "Batch 450/651, Embedding training loss: 0.5043, Classification training loss: 0.3737\n", + "Batch 500/651, Embedding training loss: 0.4552, Classification training loss: 0.2965\n", + "Batch 550/651, Embedding training loss: 0.4494, Classification training loss: 0.2355\n", + "Batch 600/651, Embedding training loss: 0.4867, Classification training loss: 0.4064\n", + "Batch 650/651, Embedding training loss: 0.6376, Classification training loss: 0.4071\n", + "Epoch 16 training finished.\n", + "Average Training Embedding Loss: 0.5953\n", + "Average Training Classification Loss: 0.4062\n", + "Training Classification Accuracy: 0.8227\n", + "Training ROC AUC: 0.8882\n", + "Training Average Precision Score: 0.8514\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.7491\n", + "Average Validation Classification Loss: 0.3371\n", + "Validation Classification Accuracy: 0.8089\n", + "Validation ROC AUC: 0.8599\n", + "Validation Average Precision Score: 0.1181\n", + "Previous best average precision score: 0.1178\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 17 ====\n", + "Batch 50/651, Embedding training loss: 0.5636, Classification training loss: 0.5146\n", + "Batch 100/651, Embedding training loss: 0.5816, Classification training loss: 0.2888\n", + "Batch 150/651, Embedding training loss: 0.6097, Classification training loss: 0.4321\n", + "Batch 200/651, Embedding training loss: 0.5214, Classification training loss: 0.4331\n", + "Batch 250/651, Embedding training loss: 0.7853, Classification training loss: 0.5401\n", + "Batch 300/651, Embedding training loss: 0.5282, Classification training loss: 0.3385\n", + "Batch 350/651, Embedding training loss: 0.4272, Classification training loss: 0.4357\n", + "Batch 400/651, Embedding training loss: 0.5382, Classification training loss: 0.3016\n", + "Batch 450/651, Embedding training loss: 0.5986, Classification training loss: 0.3380\n", + "Batch 500/651, Embedding training loss: 0.4560, Classification training loss: 0.4142\n", + "Batch 550/651, Embedding training loss: 0.6533, Classification training loss: 0.5104\n", + "Batch 600/651, Embedding training loss: 0.4958, Classification training loss: 0.2755\n", + "Batch 650/651, Embedding training loss: 0.5306, Classification training loss: 0.3764\n", + "Epoch 17 training finished.\n", + "Average Training Embedding Loss: 0.5622\n", + "Average Training Classification Loss: 0.3798\n", + "Training Classification Accuracy: 0.8386\n", + "Training ROC AUC: 0.9030\n", + "Training Average Precision Score: 0.8700\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.6363\n", + "Average Validation Classification Loss: 0.2618\n", + "Validation Classification Accuracy: 0.8636\n", + "Validation ROC AUC: 0.8773\n", + "Validation Average Precision Score: 0.1327\n", + "Previous best average precision score: 0.1181\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 18 ====\n", + "Batch 50/651, Embedding training loss: 0.5348, Classification training loss: 0.2967\n", + "Batch 100/651, Embedding training loss: 0.6011, Classification training loss: 0.2544\n", + "Batch 150/651, Embedding training loss: 0.4047, Classification training loss: 0.2752\n", + "Batch 200/651, Embedding training loss: 0.6623, Classification training loss: 0.4536\n", + "Batch 250/651, Embedding training loss: 0.5676, Classification training loss: 0.3588\n", + "Batch 300/651, Embedding training loss: 0.4478, Classification training loss: 0.3908\n", + "Batch 350/651, Embedding training loss: 0.6285, Classification training loss: 0.4450\n", + "Batch 400/651, Embedding training loss: 0.6160, Classification training loss: 0.3219\n", + "Batch 450/651, Embedding training loss: 0.4999, Classification training loss: 0.3413\n", + "Batch 500/651, Embedding training loss: 0.6249, Classification training loss: 0.5592\n", + "Batch 550/651, Embedding training loss: 0.4545, Classification training loss: 0.2910\n", + "Batch 600/651, Embedding training loss: 0.5912, Classification training loss: 0.5282\n", + "Batch 650/651, Embedding training loss: 0.5599, Classification training loss: 0.5734\n", + "Epoch 18 training finished.\n", + "Average Training Embedding Loss: 0.5210\n", + "Average Training Classification Loss: 0.3529\n", + "Training Classification Accuracy: 0.8538\n", + "Training ROC AUC: 0.9164\n", + "Training Average Precision Score: 0.8860\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.7597\n", + "Average Validation Classification Loss: 0.3233\n", + "Validation Classification Accuracy: 0.8177\n", + "Validation ROC AUC: 0.8581\n", + "Validation Average Precision Score: 0.0953\n", + "\n", + "==== Training Epoch 19 ====\n", + "Batch 50/651, Embedding training loss: 0.6091, Classification training loss: 0.4542\n", + "Batch 100/651, Embedding training loss: 0.4317, Classification training loss: 0.2660\n", + "Batch 150/651, Embedding training loss: 0.4339, Classification training loss: 0.3528\n", + "Batch 200/651, Embedding training loss: 0.4592, Classification training loss: 0.3125\n", + "Batch 250/651, Embedding training loss: 0.5677, Classification training loss: 0.3097\n", + "Batch 300/651, Embedding training loss: 0.6285, Classification training loss: 0.3751\n", + "Batch 350/651, Embedding training loss: 0.5192, Classification training loss: 0.2138\n", + "Batch 400/651, Embedding training loss: 0.4922, Classification training loss: 0.3339\n", + "Batch 450/651, Embedding training loss: 0.6566, Classification training loss: 0.3866\n", + "Batch 500/651, Embedding training loss: 0.3242, Classification training loss: 0.2338\n", + "Batch 550/651, Embedding training loss: 0.2664, Classification training loss: 0.2496\n", + "Batch 600/651, Embedding training loss: 0.3139, Classification training loss: 0.2356\n", + "Batch 650/651, Embedding training loss: 0.4131, Classification training loss: 0.4012\n", + "Epoch 19 training finished.\n", + "Average Training Embedding Loss: 0.4637\n", + "Average Training Classification Loss: 0.3220\n", + "Training Classification Accuracy: 0.8694\n", + "Training ROC AUC: 0.9296\n", + "Training Average Precision Score: 0.9037\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.7071\n", + "Average Validation Classification Loss: 0.3050\n", + "Validation Classification Accuracy: 0.8427\n", + "Validation ROC AUC: 0.8561\n", + "Validation Average Precision Score: 0.0844\n", + "\n", + "==== Training Epoch 20 ====\n", + "Batch 50/651, Embedding training loss: 0.2178, Classification training loss: 0.2208\n", + "Batch 100/651, Embedding training loss: 0.4566, Classification training loss: 0.4663\n", + "Batch 150/651, Embedding training loss: 0.7322, Classification training loss: 0.5546\n", + "Batch 200/651, Embedding training loss: 0.5214, Classification training loss: 0.4550\n", + "Batch 250/651, Embedding training loss: 0.5975, Classification training loss: 0.2593\n", + "Batch 300/651, Embedding training loss: 0.3942, Classification training loss: 0.3126\n", + "Batch 350/651, Embedding training loss: 0.3458, Classification training loss: 0.1962\n", + "Batch 400/651, Embedding training loss: 0.5950, Classification training loss: 0.3228\n", + "Batch 450/651, Embedding training loss: 0.3434, Classification training loss: 0.2602\n", + "Batch 500/651, Embedding training loss: 0.2202, Classification training loss: 0.1537\n", + "Batch 550/651, Embedding training loss: 0.2539, Classification training loss: 0.3150\n", + "Batch 600/651, Embedding training loss: 0.2676, Classification training loss: 0.2205\n", + "Batch 650/651, Embedding training loss: 0.3217, Classification training loss: 0.1518\n", + "Epoch 20 training finished.\n", + "Average Training Embedding Loss: 0.4138\n", + "Average Training Classification Loss: 0.2892\n", + "Training Classification Accuracy: 0.8860\n", + "Training ROC AUC: 0.9427\n", + "Training Average Precision Score: 0.9208\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.7208\n", + "Average Validation Classification Loss: 0.3156\n", + "Validation Classification Accuracy: 0.8349\n", + "Validation ROC AUC: 0.8468\n", + "Validation Average Precision Score: 0.0931\n", + "\n", + "==== Training Epoch 21 ====\n", + "Batch 50/651, Embedding training loss: 0.4096, Classification training loss: 0.2443\n", + "Batch 100/651, Embedding training loss: 0.3357, Classification training loss: 0.2401\n", + "Batch 150/651, Embedding training loss: 0.3034, Classification training loss: 0.0925\n", + "Batch 200/651, Embedding training loss: 0.5260, Classification training loss: 0.3276\n", + "Batch 250/651, Embedding training loss: 0.2936, Classification training loss: 0.1821\n", + "Batch 300/651, Embedding training loss: 0.2171, Classification training loss: 0.2260\n", + "Batch 350/651, Embedding training loss: 0.4013, Classification training loss: 0.1335\n", + "Batch 400/651, Embedding training loss: 0.4489, Classification training loss: 0.3482\n", + "Batch 450/651, Embedding training loss: 0.2803, Classification training loss: 0.1886\n", + "Batch 500/651, Embedding training loss: 0.4511, Classification training loss: 0.2686\n", + "Batch 550/651, Embedding training loss: 0.2236, Classification training loss: 0.1576\n", + "Batch 600/651, Embedding training loss: 0.5669, Classification training loss: 0.3578\n", + "Batch 650/651, Embedding training loss: 0.4023, Classification training loss: 0.3199\n", + "Epoch 21 training finished.\n", + "Average Training Embedding Loss: 0.3618\n", + "Average Training Classification Loss: 0.2559\n", + "Training Classification Accuracy: 0.9035\n", + "Training ROC AUC: 0.9543\n", + "Training Average Precision Score: 0.9358\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.6419\n", + "Average Validation Classification Loss: 0.2439\n", + "Validation Classification Accuracy: 0.8811\n", + "Validation ROC AUC: 0.8638\n", + "Validation Average Precision Score: 0.0947\n", + "\n", + "==== Training Epoch 22 ====\n", + "Batch 50/651, Embedding training loss: 0.1171, Classification training loss: 0.0874\n", + "Batch 100/651, Embedding training loss: 0.4400, Classification training loss: 0.3304\n", + "Batch 150/651, Embedding training loss: 0.5680, Classification training loss: 0.3058\n", + "Batch 200/651, Embedding training loss: 0.3315, Classification training loss: 0.2982\n", + "Batch 250/651, Embedding training loss: 0.3307, Classification training loss: 0.1391\n", + "Batch 300/651, Embedding training loss: 0.5008, Classification training loss: 0.3338\n", + "Batch 350/651, Embedding training loss: 0.3620, Classification training loss: 0.2957\n", + "Batch 400/651, Embedding training loss: 0.3638, Classification training loss: 0.1990\n", + "Batch 450/651, Embedding training loss: 0.2253, Classification training loss: 0.1246\n", + "Batch 500/651, Embedding training loss: 0.2272, Classification training loss: 0.2437\n", + "Batch 550/651, Embedding training loss: 0.2098, Classification training loss: 0.2413\n", + "Batch 600/651, Embedding training loss: 0.3363, Classification training loss: 0.2020\n", + "Batch 650/651, Embedding training loss: 0.3626, Classification training loss: 0.2289\n", + "Epoch 22 training finished.\n", + "Average Training Embedding Loss: 0.3151\n", + "Average Training Classification Loss: 0.2253\n", + "Training Classification Accuracy: 0.9166\n", + "Training ROC AUC: 0.9641\n", + "Training Average Precision Score: 0.9501\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.6411\n", + "Average Validation Classification Loss: 0.2238\n", + "Validation Classification Accuracy: 0.8962\n", + "Validation ROC AUC: 0.8461\n", + "Validation Average Precision Score: 0.1079\n", + "\n", + "==== Training Epoch 23 ====\n", + "Batch 50/651, Embedding training loss: 0.2112, Classification training loss: 0.1806\n", + "Batch 100/651, Embedding training loss: 0.4800, Classification training loss: 0.3415\n", + "Batch 150/651, Embedding training loss: 0.3744, Classification training loss: 0.2041\n", + "Batch 200/651, Embedding training loss: 0.1354, Classification training loss: 0.0664\n", + "Batch 250/651, Embedding training loss: 0.3826, Classification training loss: 0.2935\n", + "Batch 300/651, Embedding training loss: 0.1737, Classification training loss: 0.1439\n", + "Batch 350/651, Embedding training loss: 0.3591, Classification training loss: 0.2311\n", + "Batch 400/651, Embedding training loss: 0.0462, Classification training loss: 0.0633\n", + "Batch 450/651, Embedding training loss: 0.2281, Classification training loss: 0.1739\n", + "Batch 500/651, Embedding training loss: 0.1184, Classification training loss: 0.1509\n", + "Batch 550/651, Embedding training loss: 0.1437, Classification training loss: 0.0671\n", + "Batch 600/651, Embedding training loss: 0.2187, Classification training loss: 0.1428\n", + "Batch 650/651, Embedding training loss: 0.1784, Classification training loss: 0.1803\n", + "Epoch 23 training finished.\n", + "Average Training Embedding Loss: 0.2648\n", + "Average Training Classification Loss: 0.1985\n", + "Training Classification Accuracy: 0.9295\n", + "Training ROC AUC: 0.9716\n", + "Training Average Precision Score: 0.9621\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.6134\n", + "Average Validation Classification Loss: 0.1980\n", + "Validation Classification Accuracy: 0.9143\n", + "Validation ROC AUC: 0.8558\n", + "Validation Average Precision Score: 0.1008\n", + "\n", + "==== Training Epoch 24 ====\n", + "Batch 50/651, Embedding training loss: 0.2610, Classification training loss: 0.2025\n", + "Batch 100/651, Embedding training loss: 0.3261, Classification training loss: 0.2088\n", + "Batch 150/651, Embedding training loss: 0.0706, Classification training loss: 0.0412\n", + "Batch 200/651, Embedding training loss: 0.2358, Classification training loss: 0.1709\n", + "Batch 250/651, Embedding training loss: 0.1326, Classification training loss: 0.0834\n", + "Batch 300/651, Embedding training loss: 0.3603, Classification training loss: 0.3066\n", + "Batch 350/651, Embedding training loss: 0.1549, Classification training loss: 0.1202\n", + "Batch 400/651, Embedding training loss: 0.1006, Classification training loss: 0.0458\n", + "Batch 450/651, Embedding training loss: 0.1430, Classification training loss: 0.0989\n", + "Batch 500/651, Embedding training loss: 0.1987, Classification training loss: 0.1229\n", + "Batch 550/651, Embedding training loss: 0.5830, Classification training loss: 0.3807\n", + "Batch 600/651, Embedding training loss: 0.1961, Classification training loss: 0.2087\n", + "Batch 650/651, Embedding training loss: 0.1378, Classification training loss: 0.0542\n", + "Epoch 24 training finished.\n", + "Average Training Embedding Loss: 0.2299\n", + "Average Training Classification Loss: 0.1730\n", + "Training Classification Accuracy: 0.9412\n", + "Training ROC AUC: 0.9771\n", + "Training Average Precision Score: 0.9677\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.6288\n", + "Average Validation Classification Loss: 0.1929\n", + "Validation Classification Accuracy: 0.9167\n", + "Validation ROC AUC: 0.8428\n", + "Validation Average Precision Score: 0.1191\n", + "\n", + "==== Training Epoch 25 ====\n", + "Batch 50/651, Embedding training loss: 0.3012, Classification training loss: 0.1150\n", + "Batch 100/651, Embedding training loss: 0.1802, Classification training loss: 0.1372\n", + "Batch 150/651, Embedding training loss: 0.3079, Classification training loss: 0.3724\n", + "Batch 200/651, Embedding training loss: 0.0992, Classification training loss: 0.1121\n", + "Batch 250/651, Embedding training loss: 0.1025, Classification training loss: 0.0804\n", + "Batch 300/651, Embedding training loss: 0.1760, Classification training loss: 0.1273\n", + "Batch 350/651, Embedding training loss: 0.2501, Classification training loss: 0.3684\n", + "Batch 400/651, Embedding training loss: 0.3965, Classification training loss: 0.5171\n", + "Batch 450/651, Embedding training loss: 0.1551, Classification training loss: 0.1296\n", + "Batch 500/651, Embedding training loss: 0.1297, Classification training loss: 0.1108\n", + "Batch 550/651, Embedding training loss: 0.1015, Classification training loss: 0.0716\n", + "Batch 600/651, Embedding training loss: 0.1683, Classification training loss: 0.1902\n", + "Batch 650/651, Embedding training loss: 0.2008, Classification training loss: 0.1230\n", + "Epoch 25 training finished.\n", + "Average Training Embedding Loss: 0.2003\n", + "Average Training Classification Loss: 0.1527\n", + "Training Classification Accuracy: 0.9479\n", + "Training ROC AUC: 0.9817\n", + "Training Average Precision Score: 0.9738\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.6393\n", + "Average Validation Classification Loss: 0.1784\n", + "Validation Classification Accuracy: 0.9230\n", + "Validation ROC AUC: 0.8410\n", + "Validation Average Precision Score: 0.1329\n", + "Previous best average precision score: 0.1327\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 26 ====\n", + "Batch 50/651, Embedding training loss: 0.1266, Classification training loss: 0.1070\n", + "Batch 100/651, Embedding training loss: 0.1499, Classification training loss: 0.0866\n", + "Batch 150/651, Embedding training loss: 0.1913, Classification training loss: 0.1141\n", + "Batch 200/651, Embedding training loss: 0.0733, Classification training loss: 0.0883\n", + "Batch 250/651, Embedding training loss: 0.0604, Classification training loss: 0.0443\n", + "Batch 300/651, Embedding training loss: 0.1261, Classification training loss: 0.0398\n", + "Batch 350/651, Embedding training loss: 0.1466, Classification training loss: 0.0960\n", + "Batch 400/651, Embedding training loss: 0.1277, Classification training loss: 0.1405\n", + "Batch 450/651, Embedding training loss: 0.1452, Classification training loss: 0.1237\n", + "Batch 500/651, Embedding training loss: 0.1997, Classification training loss: 0.1550\n", + "Batch 550/651, Embedding training loss: 0.0140, Classification training loss: 0.0382\n", + "Batch 600/651, Embedding training loss: 0.3122, Classification training loss: 0.1980\n", + "Batch 650/651, Embedding training loss: 0.1221, Classification training loss: 0.1270\n", + "Epoch 26 training finished.\n", + "Average Training Embedding Loss: 0.1788\n", + "Average Training Classification Loss: 0.1406\n", + "Training Classification Accuracy: 0.9534\n", + "Training ROC AUC: 0.9842\n", + "Training Average Precision Score: 0.9778\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.6121\n", + "Average Validation Classification Loss: 0.1719\n", + "Validation Classification Accuracy: 0.9291\n", + "Validation ROC AUC: 0.8214\n", + "Validation Average Precision Score: 0.1111\n", + "\n", + "==== Training Epoch 27 ====\n", + "Batch 50/651, Embedding training loss: 0.2307, Classification training loss: 0.1413\n", + "Batch 100/651, Embedding training loss: 0.3815, Classification training loss: 0.3441\n", + "Batch 150/651, Embedding training loss: 0.2282, Classification training loss: 0.1582\n", + "Batch 200/651, Embedding training loss: 0.2157, Classification training loss: 0.1167\n", + "Batch 250/651, Embedding training loss: 0.1776, Classification training loss: 0.1278\n", + "Batch 300/651, Embedding training loss: 0.2329, Classification training loss: 0.2580\n", + "Batch 350/651, Embedding training loss: 0.0170, Classification training loss: 0.0661\n", + "Batch 400/651, Embedding training loss: 0.0815, Classification training loss: 0.0961\n", + "Batch 450/651, Embedding training loss: 0.1742, Classification training loss: 0.1731\n", + "Batch 500/651, Embedding training loss: 0.1197, Classification training loss: 0.0578\n", + "Batch 550/651, Embedding training loss: 0.2758, Classification training loss: 0.1767\n", + "Batch 600/651, Embedding training loss: 0.1647, Classification training loss: 0.1229\n", + "Batch 650/651, Embedding training loss: 0.0789, Classification training loss: 0.0524\n", + "Epoch 27 training finished.\n", + "Average Training Embedding Loss: 0.1693\n", + "Average Training Classification Loss: 0.1328\n", + "Training Classification Accuracy: 0.9551\n", + "Training ROC AUC: 0.9859\n", + "Training Average Precision Score: 0.9809\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.5960\n", + "Average Validation Classification Loss: 0.1716\n", + "Validation Classification Accuracy: 0.9288\n", + "Validation ROC AUC: 0.8402\n", + "Validation Average Precision Score: 0.1121\n", + "\n", + "==== Training Epoch 28 ====\n", + "Batch 50/651, Embedding training loss: 0.1732, Classification training loss: 0.0865\n", + "Batch 100/651, Embedding training loss: 0.1346, Classification training loss: 0.1097\n", + "Batch 150/651, Embedding training loss: 0.1316, Classification training loss: 0.0870\n", + "Batch 200/651, Embedding training loss: 0.0202, Classification training loss: 0.0323\n", + "Batch 250/651, Embedding training loss: 0.4201, Classification training loss: 0.3247\n", + "Batch 300/651, Embedding training loss: 0.1319, Classification training loss: 0.0757\n", + "Batch 350/651, Embedding training loss: 0.1695, Classification training loss: 0.1587\n", + "Batch 400/651, Embedding training loss: 0.0858, Classification training loss: 0.0690\n", + "Batch 450/651, Embedding training loss: 0.0341, Classification training loss: 0.0697\n", + "Batch 500/651, Embedding training loss: 0.3799, Classification training loss: 0.1981\n", + "Batch 550/651, Embedding training loss: 0.0697, Classification training loss: 0.0523\n", + "Batch 600/651, Embedding training loss: 0.0300, Classification training loss: 0.0570\n", + "Batch 650/651, Embedding training loss: 0.2278, Classification training loss: 0.2162\n", + "Epoch 28 training finished.\n", + "Average Training Embedding Loss: 0.1531\n", + "Average Training Classification Loss: 0.1198\n", + "Training Classification Accuracy: 0.9595\n", + "Training ROC AUC: 0.9886\n", + "Training Average Precision Score: 0.9842\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.6002\n", + "Average Validation Classification Loss: 0.1589\n", + "Validation Classification Accuracy: 0.9378\n", + "Validation ROC AUC: 0.8205\n", + "Validation Average Precision Score: 0.1279\n", + "\n", + "==== Training Epoch 29 ====\n", + "Batch 50/651, Embedding training loss: 0.0288, Classification training loss: 0.0539\n", + "Batch 100/651, Embedding training loss: 0.5394, Classification training loss: 0.4222\n", + "Batch 150/651, Embedding training loss: 0.1293, Classification training loss: 0.1050\n", + "Batch 200/651, Embedding training loss: 0.1853, Classification training loss: 0.2461\n", + "Batch 250/651, Embedding training loss: 0.2276, Classification training loss: 0.2347\n", + "Batch 300/651, Embedding training loss: 0.0000, Classification training loss: 0.0388\n", + "Batch 350/651, Embedding training loss: 0.1204, Classification training loss: 0.1454\n", + "Batch 400/651, Embedding training loss: 0.0916, Classification training loss: 0.0864\n", + "Batch 450/651, Embedding training loss: 0.2690, Classification training loss: 0.1838\n", + "Batch 500/651, Embedding training loss: 0.2087, Classification training loss: 0.2723\n", + "Batch 550/651, Embedding training loss: 0.0838, Classification training loss: 0.0509\n", + "Batch 600/651, Embedding training loss: 0.1108, Classification training loss: 0.0368\n", + "Batch 650/651, Embedding training loss: 0.0543, Classification training loss: 0.0456\n", + "Epoch 29 training finished.\n", + "Average Training Embedding Loss: 0.1495\n", + "Average Training Classification Loss: 0.1209\n", + "Training Classification Accuracy: 0.9605\n", + "Training ROC AUC: 0.9869\n", + "Training Average Precision Score: 0.9804\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.6043\n", + "Average Validation Classification Loss: 0.1678\n", + "Validation Classification Accuracy: 0.9297\n", + "Validation ROC AUC: 0.8402\n", + "Validation Average Precision Score: 0.1281\n", + "\n", + "==== Training Epoch 30 ====\n", + "Batch 50/651, Embedding training loss: 0.1203, Classification training loss: 0.1789\n", + "Batch 100/651, Embedding training loss: 0.1846, Classification training loss: 0.0909\n", + "Batch 150/651, Embedding training loss: 0.0740, Classification training loss: 0.0842\n", + "Batch 200/651, Embedding training loss: 0.1446, Classification training loss: 0.1186\n", + "Batch 250/651, Embedding training loss: 0.1666, Classification training loss: 0.0678\n", + "Batch 300/651, Embedding training loss: 0.1335, Classification training loss: 0.0762\n", + "Batch 350/651, Embedding training loss: 0.1068, Classification training loss: 0.0894\n", + "Batch 400/651, Embedding training loss: 0.1107, Classification training loss: 0.1239\n", + "Batch 450/651, Embedding training loss: 0.2519, Classification training loss: 0.1892\n", + "Batch 500/651, Embedding training loss: 0.0969, Classification training loss: 0.0693\n", + "Batch 550/651, Embedding training loss: 0.0892, Classification training loss: 0.1084\n", + "Batch 600/651, Embedding training loss: 0.1291, Classification training loss: 0.0649\n", + "Batch 650/651, Embedding training loss: 0.2508, Classification training loss: 0.1715\n", + "Epoch 30 training finished.\n", + "Average Training Embedding Loss: 0.1469\n", + "Average Training Classification Loss: 0.1153\n", + "Training Classification Accuracy: 0.9628\n", + "Training ROC AUC: 0.9891\n", + "Training Average Precision Score: 0.9850\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.5961\n", + "Average Validation Classification Loss: 0.1604\n", + "Validation Classification Accuracy: 0.9342\n", + "Validation ROC AUC: 0.8334\n", + "Validation Average Precision Score: 0.1280\n", + "\n", + "--- Training Finished ---\n", + "Best Validation Average Precision Score: 0.1329%\n" ] } ], @@ -1840,6 +2622,1327 @@ "print(f\"Best Validation Average Precision Score: {best_val_AP_score:.4f}%\")" ] }, + { + "cell_type": "code", + "execution_count": 15, + "id": "dd91f004", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 5))\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(range(NUM_EPOCHS), emb_train_loss_log, label='Train Loss', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), emb_val_loss_log, label='Validation Loss', color='#384860')\n", + "plt.title('Embedding Loss over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(range(NUM_EPOCHS), clas_train_loss_log, label='Train Loss', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), clas_val_loss_log, label='Validation Loss', color='#384860')\n", + "plt.title('Classification Loss over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('loss_logs.png')\n", + "plt.show()\n", + "#plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b517098b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 5))\n", + "\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(range(NUM_EPOCHS), train_accuracy_log, label='Train Accuracy', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), val_accuracy_log, label='Validation Accuracy', color='#384860')\n", + "plt.title('Classification Accuracy over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(range(NUM_EPOCHS), train_ROC_AUC_log, label='Train ROC AUC', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), val_ROC_AUC_log, label='Validation ROC AUC', color='#384860')\n", + "plt.title('ROC AUC over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('ROC AUC')\n", + "plt.legend()\n", + "\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(range(NUM_EPOCHS), train_AP_score_log, label='Train AP Score', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), val_AP_score_log, label='Validation AP Score', color='#384860')\n", + "plt.title('Average Precision Score over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('AP Score')\n", + "plt.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('metrics_logs.png')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "bf6527da", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.load_state_dict(torch.load((Path(DATA_ROOT) / 'best_siamese_model.pth')))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6aa07581", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3255" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#test_samples\n", + "test_samples[test_samples[\"target\"]== 0].shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "494ce41a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "58" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_samples[test_samples[\"target\"]== 1].shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "3145f029", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
isic_idpatient_idtarget
0ISIC_5925370IP_49963130
1ISIC_7676485IP_95133760
2ISIC_2766061IP_10106430
3ISIC_1298092IP_44797360
4ISIC_2657843IP_06734510
............
111ISIC_9583969IP_42811941
112ISIC_9596721IP_07250271
113ISIC_9821002IP_50637561
114ISIC_9955163IP_75072121
115ISIC_9998682IP_25161681
\n", + "

116 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " isic_id patient_id target\n", + "0 ISIC_5925370 IP_4996313 0\n", + "1 ISIC_7676485 IP_9513376 0\n", + "2 ISIC_2766061 IP_1010643 0\n", + "3 ISIC_1298092 IP_4479736 0\n", + "4 ISIC_2657843 IP_0673451 0\n", + ".. ... ... ...\n", + "111 ISIC_9583969 IP_4281194 1\n", + "112 ISIC_9596721 IP_0725027 1\n", + "113 ISIC_9821002 IP_5063756 1\n", + "114 ISIC_9955163 IP_7507212 1\n", + "115 ISIC_9998682 IP_2516168 1\n", + "\n", + "[116 rows x 3 columns]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_samples_subset = test_samples[test_samples[\"target\"]== 0].sample(n=58)\n", + "test_samples_subset = pd.concat([test_samples_subset, test_samples[test_samples[\"target\"]== 1]], ignore_index=True)\n", + "test_samples_subset" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "6f1f3fb7", + "metadata": {}, + "outputs": [], + "source": [ + "test_dataset = SkinDataset(DATA_ROOT, test_samples_subset, transform=None)\n", + "test_loader = DataLoader(test_dataset, batch_size=256, shuffle=True, num_workers=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "604d937a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Classification Accuracy: 0.6552\n", + "Test ROC AUC: 0.8954\n", + "Test Average Precision Score: 0.9038\n", + "Test Sensitivity: 0.3276\n", + "Test Specificity: 0.9828\n" + ] + } + ], + "source": [ + "from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix\n", + "model.eval()\n", + "with torch.no_grad():\n", + " test_all_labels = []\n", + " test_all_embeds = []\n", + " test_all_predictions = []\n", + " test_all_probs = []\n", + " for i, (images, labels) in enumerate(test_loader):\n", + " images = images.to(device)\n", + "\n", + " # Get embeddings\n", + " embeddings = model(images)\n", + "\n", + " # classify embeddings\n", + " output = model.classify(embeddings)\n", + "\n", + " # Predictions and Probabilities\n", + " _, preds = torch.max(output, 1)\n", + " probs = torch.softmax(output, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", + " test_all_labels.extend(labels.cpu().numpy())\n", + " test_all_embeds.extend(embeddings.cpu().numpy())\n", + " test_all_predictions.extend(preds.cpu().numpy())\n", + " test_all_probs.extend(probs.cpu().numpy())\n", + "\n", + " test_acc = accuracy_score(test_all_labels, test_all_predictions)\n", + " test_auc = roc_auc_score(test_all_labels, test_all_probs)\n", + " test_aps = average_precision_score(test_all_labels, test_all_probs)\n", + " conf_matrix = confusion_matrix(test_all_labels, test_all_predictions)\n", + " tn, fp, fn, tp = conf_matrix.ravel()\n", + " sensitivity = tp / (tp + fn)\n", + " specificity = tn / (tn + fp)\n", + "\n", + " print(f\"Test Classification Accuracy: {test_acc:.4f}\")\n", + " print(f\"Test ROC AUC: {test_auc:.4f}\")\n", + " print(f\"Test Average Precision Score: {test_aps:.4f}\")\n", + " print(f\"Test Sensitivity: {sensitivity:.4f}\")\n", + " print(f\"Test Specificity: {specificity:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "5d714b27", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "57 1 39 19\n" + ] + } + ], + "source": [ + "print(tn, fp, fn, tp)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "dec88172", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Device type?\n", + "cuda\n", + "\n", + "\n", + "Using device: cuda\n", + "Number of normal samples in training data subset: 7796\n", + "Number of melanoma samples in training data subset: 7824\n", + "\n", + "--- Starting Training ---\n", + "\n", + "==== Training Epoch 1 ====\n", + "Batch 50/489, Embedding training loss: 1.2291, Classification training loss: 0.6680\n", + "Batch 100/489, Embedding training loss: 1.2194, Classification training loss: 0.6734\n", + "Batch 150/489, Embedding training loss: 1.2103, Classification training loss: 0.6826\n", + "Batch 200/489, Embedding training loss: 1.2024, Classification training loss: 0.6869\n", + "Batch 250/489, Embedding training loss: 1.2750, Classification training loss: 0.6723\n", + "Batch 300/489, Embedding training loss: 1.2290, Classification training loss: 0.6932\n", + "Batch 350/489, Embedding training loss: 1.1804, Classification training loss: 0.6351\n", + "Batch 400/489, Embedding training loss: 1.2546, Classification training loss: 0.6403\n", + "Batch 450/489, Embedding training loss: 1.3030, Classification training loss: 0.6636\n", + "Epoch 1 training finished.\n", + "Average Training Embedding Loss: 1.2261\n", + "Average Training Classification Loss: 0.6647\n", + "Training Classification Accuracy: 0.6008\n", + "Training ROC AUC: 0.6544\n", + "Training Average Precision Score: 0.6131\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.2958\n", + "Average Validation Classification Loss: 0.4825\n", + "Validation Classification Accuracy: 0.7398\n", + "Validation ROC AUC: 0.7505\n", + "Validation Average Precision Score: 0.0379\n", + "Previous best average precision score: -1.0000\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 2 ====\n", + "Batch 50/489, Embedding training loss: 0.8047, Classification training loss: 0.4856\n", + "Batch 100/489, Embedding training loss: 1.2141, Classification training loss: 0.7160\n", + "Batch 150/489, Embedding training loss: 1.4164, Classification training loss: 0.6304\n", + "Batch 200/489, Embedding training loss: 1.0531, Classification training loss: 0.5397\n", + "Batch 250/489, Embedding training loss: 0.9719, Classification training loss: 0.5695\n", + "Batch 300/489, Embedding training loss: 1.1750, Classification training loss: 0.5823\n", + "Batch 350/489, Embedding training loss: 0.9875, Classification training loss: 0.5607\n", + "Batch 400/489, Embedding training loss: 0.9145, Classification training loss: 0.4747\n", + "Batch 450/489, Embedding training loss: 0.8770, Classification training loss: 0.6204\n", + "Epoch 2 training finished.\n", + "Average Training Embedding Loss: 1.0878\n", + "Average Training Classification Loss: 0.5825\n", + "Training Classification Accuracy: 0.6965\n", + "Training ROC AUC: 0.7470\n", + "Training Average Precision Score: 0.6878\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.2340\n", + "Average Validation Classification Loss: 0.4445\n", + "Validation Classification Accuracy: 0.7501\n", + "Validation ROC AUC: 0.7888\n", + "Validation Average Precision Score: 0.0562\n", + "Previous best average precision score: 0.0379\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 3 ====\n", + "Batch 50/489, Embedding training loss: 0.9939, Classification training loss: 0.5366\n", + "Batch 100/489, Embedding training loss: 1.1359, Classification training loss: 0.5288\n", + "Batch 150/489, Embedding training loss: 1.2352, Classification training loss: 0.6753\n", + "Batch 200/489, Embedding training loss: 1.0543, Classification training loss: 0.6233\n", + "Batch 250/489, Embedding training loss: 1.0368, Classification training loss: 0.5085\n", + "Batch 300/489, Embedding training loss: 0.9747, Classification training loss: 0.5564\n", + "Batch 350/489, Embedding training loss: 1.0565, Classification training loss: 0.6209\n", + "Batch 400/489, Embedding training loss: 0.8488, Classification training loss: 0.4494\n", + "Batch 450/489, Embedding training loss: 0.8973, Classification training loss: 0.4081\n", + "Epoch 3 training finished.\n", + "Average Training Embedding Loss: 1.0613\n", + "Average Training Classification Loss: 0.5651\n", + "Training Classification Accuracy: 0.7150\n", + "Training ROC AUC: 0.7621\n", + "Training Average Precision Score: 0.7016\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.0484\n", + "Average Validation Classification Loss: 0.3975\n", + "Validation Classification Accuracy: 0.7990\n", + "Validation ROC AUC: 0.8143\n", + "Validation Average Precision Score: 0.0634\n", + "Previous best average precision score: 0.0562\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 4 ====\n", + "Batch 50/489, Embedding training loss: 0.9976, Classification training loss: 0.5343\n", + "Batch 100/489, Embedding training loss: 0.9600, Classification training loss: 0.5241\n", + "Batch 150/489, Embedding training loss: 1.1538, Classification training loss: 0.6352\n", + "Batch 200/489, Embedding training loss: 1.1102, Classification training loss: 0.6456\n", + "Batch 250/489, Embedding training loss: 1.0006, Classification training loss: 0.3857\n", + "Batch 300/489, Embedding training loss: 0.9522, Classification training loss: 0.4590\n", + "Batch 350/489, Embedding training loss: 1.1186, Classification training loss: 0.5615\n", + "Batch 400/489, Embedding training loss: 0.8234, Classification training loss: 0.5293\n", + "Batch 450/489, Embedding training loss: 0.9531, Classification training loss: 0.5855\n", + "Epoch 4 training finished.\n", + "Average Training Embedding Loss: 1.0322\n", + "Average Training Classification Loss: 0.5532\n", + "Training Classification Accuracy: 0.7248\n", + "Training ROC AUC: 0.7704\n", + "Training Average Precision Score: 0.7096\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.1443\n", + "Average Validation Classification Loss: 0.4685\n", + "Validation Classification Accuracy: 0.7157\n", + "Validation ROC AUC: 0.8391\n", + "Validation Average Precision Score: 0.0978\n", + "Previous best average precision score: 0.0634\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 5 ====\n", + "Batch 50/489, Embedding training loss: 0.7046, Classification training loss: 0.4332\n", + "Batch 100/489, Embedding training loss: 0.9904, Classification training loss: 0.5534\n", + "Batch 150/489, Embedding training loss: 1.2673, Classification training loss: 0.5459\n", + "Batch 200/489, Embedding training loss: 1.0398, Classification training loss: 0.5066\n", + "Batch 250/489, Embedding training loss: 1.2607, Classification training loss: 0.5435\n", + "Batch 300/489, Embedding training loss: 0.8245, Classification training loss: 0.5229\n", + "Batch 350/489, Embedding training loss: 0.8250, Classification training loss: 0.4315\n", + "Batch 400/489, Embedding training loss: 1.2565, Classification training loss: 0.7454\n", + "Batch 450/489, Embedding training loss: 1.1872, Classification training loss: 0.5595\n", + "Epoch 5 training finished.\n", + "Average Training Embedding Loss: 1.0065\n", + "Average Training Classification Loss: 0.5334\n", + "Training Classification Accuracy: 0.7410\n", + "Training ROC AUC: 0.7920\n", + "Training Average Precision Score: 0.7329\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.1150\n", + "Average Validation Classification Loss: 0.4862\n", + "Validation Classification Accuracy: 0.7302\n", + "Validation ROC AUC: 0.8381\n", + "Validation Average Precision Score: 0.0796\n", + "\n", + "==== Training Epoch 6 ====\n", + "Batch 50/489, Embedding training loss: 0.7071, Classification training loss: 0.3715\n", + "Batch 100/489, Embedding training loss: 0.8809, Classification training loss: 0.5348\n", + "Batch 150/489, Embedding training loss: 1.1304, Classification training loss: 0.5191\n", + "Batch 200/489, Embedding training loss: 0.9379, Classification training loss: 0.5583\n", + "Batch 250/489, Embedding training loss: 0.8295, Classification training loss: 0.5083\n", + "Batch 300/489, Embedding training loss: 1.0361, Classification training loss: 0.4711\n", + "Batch 350/489, Embedding training loss: 0.8055, Classification training loss: 0.4332\n", + "Batch 400/489, Embedding training loss: 0.8884, Classification training loss: 0.4814\n", + "Batch 450/489, Embedding training loss: 0.7873, Classification training loss: 0.6087\n", + "Epoch 6 training finished.\n", + "Average Training Embedding Loss: 0.9771\n", + "Average Training Classification Loss: 0.5211\n", + "Training Classification Accuracy: 0.7504\n", + "Training ROC AUC: 0.8060\n", + "Training Average Precision Score: 0.7527\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.2448\n", + "Average Validation Classification Loss: 0.5176\n", + "Validation Classification Accuracy: 0.6526\n", + "Validation ROC AUC: 0.8336\n", + "Validation Average Precision Score: 0.0824\n", + "\n", + "==== Training Epoch 7 ====\n", + "Batch 50/489, Embedding training loss: 0.7515, Classification training loss: 0.6266\n", + "Batch 100/489, Embedding training loss: 0.9081, Classification training loss: 0.4062\n", + "Batch 150/489, Embedding training loss: 0.8902, Classification training loss: 0.4663\n", + "Batch 200/489, Embedding training loss: 0.8343, Classification training loss: 0.3998\n", + "Batch 250/489, Embedding training loss: 0.9761, Classification training loss: 0.4855\n", + "Batch 300/489, Embedding training loss: 0.8061, Classification training loss: 0.3599\n", + "Batch 350/489, Embedding training loss: 0.8639, Classification training loss: 0.3803\n", + "Batch 400/489, Embedding training loss: 0.7286, Classification training loss: 0.4330\n", + "Batch 450/489, Embedding training loss: 0.9876, Classification training loss: 0.6691\n", + "Epoch 7 training finished.\n", + "Average Training Embedding Loss: 0.9593\n", + "Average Training Classification Loss: 0.5091\n", + "Training Classification Accuracy: 0.7542\n", + "Training ROC AUC: 0.8152\n", + "Training Average Precision Score: 0.7604\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.9520\n", + "Average Validation Classification Loss: 0.4185\n", + "Validation Classification Accuracy: 0.7860\n", + "Validation ROC AUC: 0.8480\n", + "Validation Average Precision Score: 0.0984\n", + "Previous best average precision score: 0.0978\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 8 ====\n", + "Batch 50/489, Embedding training loss: 1.1922, Classification training loss: 0.6307\n", + "Batch 100/489, Embedding training loss: 0.6090, Classification training loss: 0.4098\n", + "Batch 150/489, Embedding training loss: 1.0738, Classification training loss: 0.5409\n", + "Batch 200/489, Embedding training loss: 0.5387, Classification training loss: 0.3968\n", + "Batch 250/489, Embedding training loss: 0.8203, Classification training loss: 0.5223\n", + "Batch 300/489, Embedding training loss: 0.5687, Classification training loss: 0.3749\n", + "Batch 350/489, Embedding training loss: 1.0524, Classification training loss: 0.5344\n", + "Batch 400/489, Embedding training loss: 1.0448, Classification training loss: 0.5943\n", + "Batch 450/489, Embedding training loss: 0.8032, Classification training loss: 0.4603\n", + "Epoch 8 training finished.\n", + "Average Training Embedding Loss: 0.9326\n", + "Average Training Classification Loss: 0.4873\n", + "Training Classification Accuracy: 0.7691\n", + "Training ROC AUC: 0.8327\n", + "Training Average Precision Score: 0.7865\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.0012\n", + "Average Validation Classification Loss: 0.3784\n", + "Validation Classification Accuracy: 0.7908\n", + "Validation ROC AUC: 0.8465\n", + "Validation Average Precision Score: 0.0687\n", + "\n", + "==== Training Epoch 9 ====\n", + "Batch 50/489, Embedding training loss: 0.9461, Classification training loss: 0.4141\n", + "Batch 100/489, Embedding training loss: 1.0565, Classification training loss: 0.5334\n", + "Batch 150/489, Embedding training loss: 0.6842, Classification training loss: 0.4306\n", + "Batch 200/489, Embedding training loss: 1.0137, Classification training loss: 0.5925\n", + "Batch 250/489, Embedding training loss: 0.8436, Classification training loss: 0.5257\n", + "Batch 300/489, Embedding training loss: 0.7291, Classification training loss: 0.4630\n", + "Batch 350/489, Embedding training loss: 0.6523, Classification training loss: 0.5455\n", + "Batch 400/489, Embedding training loss: 1.0234, Classification training loss: 0.5034\n", + "Batch 450/489, Embedding training loss: 0.9522, Classification training loss: 0.5249\n", + "Epoch 9 training finished.\n", + "Average Training Embedding Loss: 0.9134\n", + "Average Training Classification Loss: 0.4819\n", + "Training Classification Accuracy: 0.7716\n", + "Training ROC AUC: 0.8385\n", + "Training Average Precision Score: 0.7960\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.0863\n", + "Average Validation Classification Loss: 0.5239\n", + "Validation Classification Accuracy: 0.6755\n", + "Validation ROC AUC: 0.8486\n", + "Validation Average Precision Score: 0.0837\n", + "\n", + "==== Training Epoch 10 ====\n", + "Batch 50/489, Embedding training loss: 0.7764, Classification training loss: 0.3838\n", + "Batch 100/489, Embedding training loss: 0.7079, Classification training loss: 0.3477\n", + "Batch 150/489, Embedding training loss: 1.3955, Classification training loss: 0.6052\n", + "Batch 200/489, Embedding training loss: 0.9525, Classification training loss: 0.5056\n", + "Batch 250/489, Embedding training loss: 0.8475, Classification training loss: 0.4863\n", + "Batch 300/489, Embedding training loss: 1.2050, Classification training loss: 0.5832\n", + "Batch 350/489, Embedding training loss: 0.7028, Classification training loss: 0.4814\n", + "Batch 400/489, Embedding training loss: 0.9383, Classification training loss: 0.4145\n", + "Batch 450/489, Embedding training loss: 0.8320, Classification training loss: 0.4840\n", + "Epoch 10 training finished.\n", + "Average Training Embedding Loss: 0.8878\n", + "Average Training Classification Loss: 0.4655\n", + "Training Classification Accuracy: 0.7816\n", + "Training ROC AUC: 0.8486\n", + "Training Average Precision Score: 0.8007\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.8475\n", + "Average Validation Classification Loss: 0.3209\n", + "Validation Classification Accuracy: 0.8500\n", + "Validation ROC AUC: 0.8682\n", + "Validation Average Precision Score: 0.1525\n", + "Previous best average precision score: 0.0984\n", + "Saving best model...\n", + "\n", + "==== Training Epoch 11 ====\n", + "Batch 50/489, Embedding training loss: 0.8370, Classification training loss: 0.4316\n", + "Batch 100/489, Embedding training loss: 0.7519, Classification training loss: 0.5466\n", + "Batch 150/489, Embedding training loss: 0.6813, Classification training loss: 0.3645\n", + "Batch 200/489, Embedding training loss: 0.7656, Classification training loss: 0.4648\n", + "Batch 250/489, Embedding training loss: 0.7759, Classification training loss: 0.4096\n", + "Batch 300/489, Embedding training loss: 0.7819, Classification training loss: 0.3226\n", + "Batch 350/489, Embedding training loss: 0.8087, Classification training loss: 0.3124\n", + "Batch 400/489, Embedding training loss: 0.7234, Classification training loss: 0.3700\n", + "Batch 450/489, Embedding training loss: 0.9664, Classification training loss: 0.5462\n", + "Epoch 11 training finished.\n", + "Average Training Embedding Loss: 0.8482\n", + "Average Training Classification Loss: 0.4560\n", + "Training Classification Accuracy: 0.7901\n", + "Training ROC AUC: 0.8559\n", + "Training Average Precision Score: 0.8123\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.0040\n", + "Average Validation Classification Loss: 0.4409\n", + "Validation Classification Accuracy: 0.7458\n", + "Validation ROC AUC: 0.8552\n", + "Validation Average Precision Score: 0.1177\n", + "\n", + "==== Training Epoch 12 ====\n", + "Batch 50/489, Embedding training loss: 0.9079, Classification training loss: 0.4749\n", + "Batch 100/489, Embedding training loss: 1.0245, Classification training loss: 0.5596\n", + "Batch 150/489, Embedding training loss: 0.7863, Classification training loss: 0.4130\n", + "Batch 200/489, Embedding training loss: 0.5819, Classification training loss: 0.4200\n", + "Batch 250/489, Embedding training loss: 0.6744, Classification training loss: 0.4530\n", + "Batch 300/489, Embedding training loss: 0.7230, Classification training loss: 0.4699\n", + "Batch 350/489, Embedding training loss: 0.8756, Classification training loss: 0.3615\n", + "Batch 400/489, Embedding training loss: 1.0906, Classification training loss: 0.4844\n", + "Batch 450/489, Embedding training loss: 1.0297, Classification training loss: 0.4125\n", + "Epoch 12 training finished.\n", + "Average Training Embedding Loss: 0.8197\n", + "Average Training Classification Loss: 0.4362\n", + "Training Classification Accuracy: 0.8038\n", + "Training ROC AUC: 0.8702\n", + "Training Average Precision Score: 0.8317\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 1.0155\n", + "Average Validation Classification Loss: 0.4283\n", + "Validation Classification Accuracy: 0.7468\n", + "Validation ROC AUC: 0.8480\n", + "Validation Average Precision Score: 0.1488\n", + "\n", + "==== Training Epoch 13 ====\n", + "Batch 50/489, Embedding training loss: 0.9346, Classification training loss: 0.4521\n", + "Batch 100/489, Embedding training loss: 0.9398, Classification training loss: 0.4260\n", + "Batch 150/489, Embedding training loss: 0.8344, Classification training loss: 0.4103\n", + "Batch 200/489, Embedding training loss: 1.0912, Classification training loss: 0.5821\n", + "Batch 250/489, Embedding training loss: 0.8141, Classification training loss: 0.5899\n", + "Batch 300/489, Embedding training loss: 0.6168, Classification training loss: 0.3816\n", + "Batch 350/489, Embedding training loss: 0.9447, Classification training loss: 0.5373\n", + "Batch 400/489, Embedding training loss: 0.7222, Classification training loss: 0.3465\n", + "Batch 450/489, Embedding training loss: 0.7424, Classification training loss: 0.3280\n", + "Epoch 13 training finished.\n", + "Average Training Embedding Loss: 0.7580\n", + "Average Training Classification Loss: 0.4129\n", + "Training Classification Accuracy: 0.8156\n", + "Training ROC AUC: 0.8851\n", + "Training Average Precision Score: 0.8490\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.9018\n", + "Average Validation Classification Loss: 0.4177\n", + "Validation Classification Accuracy: 0.8017\n", + "Validation ROC AUC: 0.8432\n", + "Validation Average Precision Score: 0.1247\n", + "\n", + "==== Training Epoch 14 ====\n", + "Batch 50/489, Embedding training loss: 0.7272, Classification training loss: 0.2752\n", + "Batch 100/489, Embedding training loss: 0.6938, Classification training loss: 0.2847\n", + "Batch 150/489, Embedding training loss: 0.8206, Classification training loss: 0.4087\n", + "Batch 200/489, Embedding training loss: 0.6333, Classification training loss: 0.4039\n", + "Batch 250/489, Embedding training loss: 0.6019, Classification training loss: 0.3542\n", + "Batch 300/489, Embedding training loss: 0.7713, Classification training loss: 0.4673\n", + "Batch 350/489, Embedding training loss: 0.9842, Classification training loss: 0.4334\n", + "Batch 400/489, Embedding training loss: 1.1315, Classification training loss: 0.6579\n", + "Batch 450/489, Embedding training loss: 0.5050, Classification training loss: 0.2770\n", + "Epoch 14 training finished.\n", + "Average Training Embedding Loss: 0.7081\n", + "Average Training Classification Loss: 0.3841\n", + "Training Classification Accuracy: 0.8328\n", + "Training ROC AUC: 0.9030\n", + "Training Average Precision Score: 0.8778\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.9972\n", + "Average Validation Classification Loss: 0.4291\n", + "Validation Classification Accuracy: 0.7781\n", + "Validation ROC AUC: 0.8494\n", + "Validation Average Precision Score: 0.1103\n", + "\n", + "==== Training Epoch 15 ====\n", + "Batch 50/489, Embedding training loss: 0.6011, Classification training loss: 0.4842\n", + "Batch 100/489, Embedding training loss: 0.6779, Classification training loss: 0.2488\n", + "Batch 150/489, Embedding training loss: 0.8385, Classification training loss: 0.4391\n", + "Batch 200/489, Embedding training loss: 0.5015, Classification training loss: 0.3545\n", + "Batch 250/489, Embedding training loss: 0.6723, Classification training loss: 0.4841\n", + "Batch 300/489, Embedding training loss: 0.7481, Classification training loss: 0.4509\n", + "Batch 350/489, Embedding training loss: 0.7315, Classification training loss: 0.5749\n", + "Batch 400/489, Embedding training loss: 0.6282, Classification training loss: 0.3294\n", + "Batch 450/489, Embedding training loss: 0.6168, Classification training loss: 0.2894\n", + "Epoch 15 training finished.\n", + "Average Training Embedding Loss: 0.6638\n", + "Average Training Classification Loss: 0.3619\n", + "Training Classification Accuracy: 0.8440\n", + "Training ROC AUC: 0.9143\n", + "Training Average Precision Score: 0.8896\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.9055\n", + "Average Validation Classification Loss: 0.3784\n", + "Validation Classification Accuracy: 0.8201\n", + "Validation ROC AUC: 0.8651\n", + "Validation Average Precision Score: 0.1353\n", + "\n", + "==== Training Epoch 16 ====\n", + "Batch 50/489, Embedding training loss: 0.7199, Classification training loss: 0.2905\n", + "Batch 100/489, Embedding training loss: 0.5666, Classification training loss: 0.3682\n", + "Batch 150/489, Embedding training loss: 0.6456, Classification training loss: 0.2678\n", + "Batch 200/489, Embedding training loss: 0.4826, Classification training loss: 0.3925\n", + "Batch 250/489, Embedding training loss: 0.6621, Classification training loss: 0.3852\n", + "Batch 300/489, Embedding training loss: 0.6358, Classification training loss: 0.2368\n", + "Batch 350/489, Embedding training loss: 0.9896, Classification training loss: 0.4358\n", + "Batch 400/489, Embedding training loss: 0.5779, Classification training loss: 0.4536\n", + "Batch 450/489, Embedding training loss: 0.6011, Classification training loss: 0.2955\n", + "Epoch 16 training finished.\n", + "Average Training Embedding Loss: 0.5880\n", + "Average Training Classification Loss: 0.3311\n", + "Training Classification Accuracy: 0.8645\n", + "Training ROC AUC: 0.9286\n", + "Training Average Precision Score: 0.9084\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.8240\n", + "Average Validation Classification Loss: 0.3156\n", + "Validation Classification Accuracy: 0.8605\n", + "Validation ROC AUC: 0.8583\n", + "Validation Average Precision Score: 0.1277\n", + "\n", + "==== Training Epoch 17 ====\n", + "Batch 50/489, Embedding training loss: 0.5832, Classification training loss: 0.3522\n", + "Batch 100/489, Embedding training loss: 0.5511, Classification training loss: 0.2928\n", + "Batch 150/489, Embedding training loss: 0.6798, Classification training loss: 0.3243\n", + "Batch 200/489, Embedding training loss: 0.5882, Classification training loss: 0.3193\n", + "Batch 250/489, Embedding training loss: 0.6279, Classification training loss: 0.3731\n", + "Batch 300/489, Embedding training loss: 0.3162, Classification training loss: 0.2309\n", + "Batch 350/489, Embedding training loss: 0.7458, Classification training loss: 0.5176\n", + "Batch 400/489, Embedding training loss: 0.6052, Classification training loss: 0.3291\n", + "Batch 450/489, Embedding training loss: 0.4317, Classification training loss: 0.3208\n", + "Epoch 17 training finished.\n", + "Average Training Embedding Loss: 0.5311\n", + "Average Training Classification Loss: 0.3051\n", + "Training Classification Accuracy: 0.8770\n", + "Training ROC AUC: 0.9391\n", + "Training Average Precision Score: 0.9227\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.8601\n", + "Average Validation Classification Loss: 0.3138\n", + "Validation Classification Accuracy: 0.8581\n", + "Validation ROC AUC: 0.8470\n", + "Validation Average Precision Score: 0.1418\n", + "\n", + "==== Training Epoch 18 ====\n", + "Batch 50/489, Embedding training loss: 0.3317, Classification training loss: 0.1909\n", + "Batch 100/489, Embedding training loss: 0.7411, Classification training loss: 0.5114\n", + "Batch 150/489, Embedding training loss: 0.4861, Classification training loss: 0.2024\n", + "Batch 200/489, Embedding training loss: 0.3582, Classification training loss: 0.2171\n", + "Batch 250/489, Embedding training loss: 0.1845, Classification training loss: 0.1851\n", + "Batch 300/489, Embedding training loss: 0.5099, Classification training loss: 0.2847\n", + "Batch 350/489, Embedding training loss: 0.5629, Classification training loss: 0.4387\n", + "Batch 400/489, Embedding training loss: 0.7201, Classification training loss: 0.4175\n", + "Batch 450/489, Embedding training loss: 0.3677, Classification training loss: 0.1556\n", + "Epoch 18 training finished.\n", + "Average Training Embedding Loss: 0.5013\n", + "Average Training Classification Loss: 0.2844\n", + "Training Classification Accuracy: 0.8862\n", + "Training ROC AUC: 0.9472\n", + "Training Average Precision Score: 0.9316\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.8068\n", + "Average Validation Classification Loss: 0.2969\n", + "Validation Classification Accuracy: 0.8675\n", + "Validation ROC AUC: 0.8571\n", + "Validation Average Precision Score: 0.1223\n", + "\n", + "==== Training Epoch 19 ====\n", + "Batch 50/489, Embedding training loss: 0.3720, Classification training loss: 0.2351\n", + "Batch 100/489, Embedding training loss: 0.4788, Classification training loss: 0.2993\n", + "Batch 150/489, Embedding training loss: 0.7006, Classification training loss: 0.2711\n", + "Batch 200/489, Embedding training loss: 0.3871, Classification training loss: 0.2756\n", + "Batch 250/489, Embedding training loss: 0.4363, Classification training loss: 0.3009\n", + "Batch 300/489, Embedding training loss: 0.2995, Classification training loss: 0.2389\n", + "Batch 350/489, Embedding training loss: 0.7177, Classification training loss: 0.3023\n", + "Batch 400/489, Embedding training loss: 0.6801, Classification training loss: 0.2852\n", + "Batch 450/489, Embedding training loss: 0.6890, Classification training loss: 0.4224\n", + "Epoch 19 training finished.\n", + "Average Training Embedding Loss: 0.4810\n", + "Average Training Classification Loss: 0.2712\n", + "Training Classification Accuracy: 0.8942\n", + "Training ROC AUC: 0.9513\n", + "Training Average Precision Score: 0.9356\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.8278\n", + "Average Validation Classification Loss: 0.2908\n", + "Validation Classification Accuracy: 0.8708\n", + "Validation ROC AUC: 0.8513\n", + "Validation Average Precision Score: 0.1382\n", + "\n", + "==== Training Epoch 20 ====\n", + "Batch 50/489, Embedding training loss: 0.5060, Classification training loss: 0.2847\n", + "Batch 100/489, Embedding training loss: 0.8125, Classification training loss: 0.4230\n", + "Batch 150/489, Embedding training loss: 0.4068, Classification training loss: 0.2326\n", + "Batch 200/489, Embedding training loss: 0.1864, Classification training loss: 0.1215\n", + "Batch 250/489, Embedding training loss: 0.5415, Classification training loss: 0.2060\n", + "Batch 300/489, Embedding training loss: 0.4179, Classification training loss: 0.2265\n", + "Batch 350/489, Embedding training loss: 0.1340, Classification training loss: 0.1215\n", + "Batch 400/489, Embedding training loss: 0.2643, Classification training loss: 0.1865\n", + "Batch 450/489, Embedding training loss: 0.4048, Classification training loss: 0.2571\n", + "Epoch 20 training finished.\n", + "Average Training Embedding Loss: 0.4688\n", + "Average Training Classification Loss: 0.2690\n", + "Training Classification Accuracy: 0.8953\n", + "Training ROC AUC: 0.9519\n", + "Training Average Precision Score: 0.9344\n", + "--- Validation phase ---\n", + "Average Validation Embedding Loss: 0.8669\n", + "Average Validation Classification Loss: 0.3342\n", + "Validation Classification Accuracy: 0.8467\n", + "Validation ROC AUC: 0.8533\n", + "Validation Average Precision Score: 0.1161\n", + "\n", + "--- Training Finished ---\n", + "Best Validation Average Precision Score: 0.1525%\n" + ] + } + ], + "source": [ + "# --- Configuration ---\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(\"Device type?\")\n", + "print(device)\n", + "print(\"\\n\")\n", + "\n", + "# Define the paths and parameters prompt 2\n", + "DATA_ROOT = './data' # IMPORTANT: structure of the data root should be data-root> train-metadata.csv\n", + "IMAGE_SIZE = 256 #128\n", + "EMBEDDING_DIM = 128\n", + "MARGIN = 1.25\n", + "#BATCH_SIZE = 16\n", + "NUM_EPOCHS = 20\n", + "LEARNING_RATE = 1e-4\n", + "\n", + "# Hyperparameters prompt 1\n", + "#NUM_SAMPLES = 1500 # Simulate a subset of the dataset\n", + "#VALIDATION_SIZE = 0.1\n", + "#TEST_SIZE = 0.1 #0.2\n", + "TRAIN_BATCH_SIZE = 32 #64\n", + "VAL_TEST_BATCH_SIZE = 512\n", + "#EMBEDDING_DIM = 128\n", + "#MARGIN = 1.0 # Triplet Loss margin\n", + "#LEARNING_RATE = 1e-4\n", + "#NUM_EPOCHS = 20 # Training epochs for the Siamese Network\n", + "#NUM_EPOCHS_CLASSIFIER = 10 # Training epochs for the final classifier\n", + "\n", + "\n", + "print(f\"Using device: {device}\")\n", + "\n", + "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", + "train_samples = train_samples.sample(frac=0.3).reset_index(drop=True)#frac=0.4\n", + "print(f\"Number of normal samples in training data subset: {train_samples[train_samples[\"target\"]== 0].shape[0]}\")\n", + "print(f\"Number of melanoma samples in training data subset: {train_samples[train_samples[\"target\"]== 1].shape[0]}\")\n", + "\n", + "# Setup DataLoaders\n", + "train_dataset = TripletDataset(DATA_ROOT, train_samples,\n", + " transform=transforms.Compose([\n", + " transforms.RandomRotation(degrees=10, fill=(255, 255, 255)),\n", + " transforms.RandomHorizontalFlip(p=0.5),\n", + " transforms.RandomVerticalFlip(p=0.5),\n", + " transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.05)\n", + " ]))\n", + "\n", + "val_dataset = TripletDataset(DATA_ROOT, val_samples, transform=None)\n", + "\n", + "\n", + "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=0)\n", + "val_loader = DataLoader(val_dataset, batch_size=256, shuffle=True, num_workers=0)\n", + "\n", + "# Setup Model, Loss, Optimizer\n", + "model = EmbeddingNet(out_dim=EMBEDDING_DIM).to(device)\n", + "#model = SiameseNet(embedding_net).to(device)\n", + "criterion = TripletLoss(margin=MARGIN).to(device)\n", + "classifier_crit = nn.CrossEntropyLoss().to(device)\n", + "optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)\n", + "scheduler = optim.lr_scheduler.OneCycleLR(optimizer, max_lr=LEARNING_RATE, steps_per_epoch=train_samples.shape[0]//32//100,epochs=NUM_EPOCHS, anneal_strategy=\"cos\")\n", + "\n", + "# Training Loop\n", + "best_val_AP_score = -1.0\n", + "# metric logging\n", + "emb_train_loss_log = []\n", + "emb_val_loss_log = []\n", + "clas_train_loss_log = []\n", + "clas_val_loss_log = []\n", + "train_accuracy_log = []\n", + "val_accuracy_log = []\n", + "train_ROC_AUC_log = []\n", + "val_ROC_AUC_log = []\n", + "train_AP_score_log = []\n", + "val_AP_score_log = []\n", + "\n", + "print(\"\\n--- Starting Training ---\")\n", + "for epoch in range(1, NUM_EPOCHS + 1):#NUM_EPOCHS\n", + " # Train\n", + " print(f\"\\n==== Training Epoch {epoch} ====\")\n", + " emb_train_loss, class_train_loss, train_acc, train_auc, train_aps = train_epoch(model, train_loader, criterion, classifier_crit, optimizer, scheduler, device)\n", + "\n", + " print(f\"Epoch {epoch} training finished.\")\n", + " print(f\"Average Training Embedding Loss: {emb_train_loss:.4f}\")\n", + " print(f\"Average Training Classification Loss: {class_train_loss:.4f}\")\n", + " print(f\"Training Classification Accuracy: {train_acc:.4f}\")\n", + " print(f\"Training ROC AUC: {train_auc:.4f}\")\n", + " print(f\"Training Average Precision Score: {train_aps:.4f}\")\n", + "\n", + " emb_train_loss_log.append(emb_train_loss)\n", + " clas_train_loss_log.append(class_train_loss)\n", + " train_accuracy_log.append(train_acc)\n", + " train_ROC_AUC_log.append(train_auc)\n", + " train_AP_score_log.append(train_aps)\n", + " \n", + " # Evaluate\n", + " emb_val_loss, class_val_loss, val_acc, val_auc, val_aps = evaluate(model, val_loader, criterion, classifier_crit, device)\n", + " \n", + " print(\"--- Validation phase ---\")\n", + " print(f\"Average Validation Embedding Loss: {emb_val_loss:.4f}\")\n", + " print(f\"Average Validation Classification Loss: {class_val_loss:.4f}\")\n", + " print(f\"Validation Classification Accuracy: {val_acc:.4f}\")\n", + " print(f\"Validation ROC AUC: {val_auc:.4f}\")\n", + " print(f\"Validation Average Precision Score: {val_aps:.4f}\")\n", + "\n", + " emb_val_loss_log.append(emb_val_loss)\n", + " clas_val_loss_log.append(class_val_loss)\n", + " val_accuracy_log.append(val_acc)\n", + " val_ROC_AUC_log.append(val_auc)\n", + " val_AP_score_log.append(val_aps)\n", + "\n", + " # Save best model\n", + " if val_aps > best_val_AP_score:\n", + " print(f\"Previous best average precision score: {best_val_AP_score:.4f}\")\n", + " best_val_AP_score = val_aps\n", + " print(\"Saving best model...\")\n", + " torch.save(model.state_dict(), (Path(DATA_ROOT) / 'best_siamese_model.pth'))\n", + " \n", + "print(\"\\n--- Training Finished ---\")\n", + "print(f\"Best Validation Average Precision Score: {best_val_AP_score:.4f}%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "00c9d993", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAHqCAYAAAAZLi26AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xdc09f6wPFPEvbeG0EUFByIs+6FW6vVqp2O2m3X7brX29Za29vertvertv1s3ar1apt3dta98CJijJFhoKAbEi+vz8wqSmojIQAPu/XK6+XfPPN+T4hkZMn55znqBRFURBCCCGEEEIIIYTJqS0dgBBCCCGEEEII0VJJ0i2EEEIIIYQQQpiJJN1CCCGEEEIIIYSZSNIthBBCCCGEEEKYiSTdQgghhBBCCCGEmUjSLYQQQgghhBBCmIkk3UIIIYQQQgghhJlI0i2EEEIIIYQQQpiJJN1CCCGEEEIIIYSZSNItWozQ0FDGjh1r9uskJyejUqlYuHDhDc+dMWMGoaGhRsdUKhXz5s0zS2xCXK2x/k8IIW4OoaGhzJgxw2LXr6lPLSws5P7778fPzw+VSsVTTz1Vp37a1AYNGsSgQYMa/bri5qNSqXjssccsHYaoJUm6hVktXLgQlUp1zdvu3bstHeJNQ/8h5J133rF0KC1GaGjoNd/bI0eOtHR4QghRK2fPnuWhhx4iLCwMOzs7XFxc6Nu3L//9738pKSmxdHjX9frrr7Nw4UIeeeQRvv32W+69916zX/PEiRPMmzeP5ORks1+rtrZu3YpKpWLp0qWWDqXFuN7n14cfftjS4YlmxsrSAYibw/z582ndunW1423btrVANJZVUlKClZX812spunTpwjPPPFPteEBAgAWiEUKIulm1ahWTJ0/G1taWadOm0bFjR8rLy9mxYwfPPfccx48f5/PPP7d0mAB88cUX6HQ6o2ObN2/mlltu4eWXXzYcUxSFkpISrK2tzRLHiRMneOWVVxg0aFC1kff169eb5ZrCMoYNG8a0adOqHY+IiLBANKI5k0/+olGMGjWK7t27WzqMJsHOzs7SIYhaqqysRKfTYWNjc81zAgMDueeeexoxKiGEMI2kpCTuuOMOQkJC2Lx5M/7+/ob7Zs+ezZkzZ1i1apUFIzRWUxKdnZ1NVFSU0TGVSmWxvvZ6/YVoWkpLS7GxsUGtvvbE34iICOnjhUnI9HLRJFw99fnjjz8mLCwMBwcHhg8fTlpaGoqi8OqrrxIUFIS9vT3jx48nNze3xrbWr19Ply5dsLOzIyoqip9//rnaOXl5eTz11FMEBwdja2tL27ZtefPNN6t9g56Xl8eMGTNwdXXFzc2N6dOnk5eXV+N1V6xYQceOHbGzs6Njx44sX768xvP+uqZ73rx5qFQqzpw5w4wZM3Bzc8PV1ZWZM2dSXFxs9NiSkhKeeOIJvLy8cHZ25tZbbyU9Pd2k68Szs7OZNWsWvr6+2NnZER0dzddff13tvEWLFtGtWzecnZ1xcXGhU6dO/Pe//zXcX1FRwSuvvEJ4eDh2dnZ4enrSr18/NmzYcMMYEhMTmTx5Mh4eHjg4OHDLLbcYffDLysrCysqKV155pdpjT506hUql4qOPPjIcq83rffV78P3336dNmzbY2tpy4sSJWv/urmXGjBk4OTmRmJjIiBEjcHR0JCAggPnz56MoitG5RUVFPPPMM4ZY27VrxzvvvFPtPIDvvvuOnj174uDggLu7OwMGDKhxlGXHjh307NkTOzs7wsLC+Oabb4zub8hrJYRovt566y0KCwv5v//7P6OEW69t27Y8+eST13x8bm4uzz77LJ06dcLJyQkXFxdGjRrF4cOHq5374Ycf0qFDB8Pfq+7du/PDDz8Y7r98+TJPPfUUoaGh2Nra4uPjw7Bhwzh48KDhnKvXdOunUyclJbFq1SrDtN/k5ORrruk+efIkU6ZMwdvbG3t7e9q1a8cLL7xguD8lJYVHH32Udu3aYW9vj6enJ5MnTzaaRr5w4UImT54MwODBgw3X3bp1K1Dzmu7a9KtX90Gff/65oQ/q0aMH+/btu+ZrUFc36l/1TPF6XcuhQ4cYNWoULi4uODk5MXToUKPlhvv370elUtX42WPdunWoVCp+++03w7H09HTuu+8+fH19sbW1pUOHDixYsMDocfr3y6JFi3jxxRcJDAzEwcGBgoKCWv3ermfQoEF07NiRAwcO0KdPH+zt7WndujWffvpptXNr+xlLp9Px3//+l06dOmFnZ4e3tzcjR45k//791c7Vf/7UP/e1a9ca3d+Q10qYjox0i0aRn5/PxYsXjY6pVCo8PT2Njn3//feUl5fz+OOPk5uby1tvvcWUKVMYMmQIW7du5e9//ztnzpzhww8/5Nlnn632RzUhIYGpU6fy8MMPM336dL766ismT57M2rVrGTZsGADFxcUMHDiQ9PR0HnroIVq1asXOnTuZM2cOGRkZvP/++0DV9LTx48ezY8cOHn74YSIjI1m+fDnTp0+v9vzWr1/PpEmTiIqK4o033iAnJ4eZM2cSFBRU69/RlClTaN26NW+88QYHDx7kyy+/xMfHhzfffNNwzowZM1iyZAn33nsvt9xyC9u2bWPMmDG1vsaNlJSUMGjQIM6cOcNjjz1G69at+emnn5gxYwZ5eXmGD18bNmzgzjvvZOjQoYb44uPj+eOPPwznzJs3jzfeeIP777+fnj17UlBQwP79+zl48KDhtahJVlYWffr0obi4mCeeeAJPT0++/vprbr31VpYuXcptt92Gr68vAwcOZMmSJUZTCgEWL16MRqMxfCiq7eut99VXX1FaWsqDDz6Ira0tHh4e1/2dVVRUVHtvAzg6OmJvb2/4WavVMnLkSG655Rbeeust1q5dy8svv0xlZSXz588Hqt5zt956K1u2bGHWrFl06dKFdevW8dxzz5Gens57771naO+VV15h3rx59OnTh/nz52NjY8OePXvYvHkzw4cPN5x35swZbr/9dmbNmsX06dNZsGABM2bMoFu3bnTo0KFBr5UQonn79ddfCQsLo0+fPvV6fGJiIitWrGDy5Mm0bt2arKwsPvvsMwYOHMiJEycMy2y++OILnnjiCW6//XaefPJJSktLOXLkCHv27OGuu+4C4OGHH2bp0qU89thjREVFkZOTw44dO4iPj6dr167Vrh0ZGcm3337L3/72N4KCggzLfLy9vblw4UK1848cOUL//v2xtrbmwQcfJDQ0lLNnz/Lrr7/yr3/9C4B9+/axc+dO7rjjDoKCgkhOTuZ///sfgwYN4sSJEzg4ODBgwACeeOIJPvjgA/75z38SGRlpiKcmte1X9X744QcuX77MQw89hEql4q233mLixIkkJiY2eLp8bfpXMM/rpXf8+HH69++Pi4sLzz//PNbW1nz22WcMGjSIbdu20atXL7p3705YWBhLliyp9plr8eLFuLu7M2LECMNzuuWWWwxFxby9vVmzZg2zZs2ioKCAp556yujxr776KjY2Njz77LOUlZXdcGZCaWlpjX28i4uL0WMvXbrE6NGjmTJlCnfeeSdLlizhkUcewcbGhvvuuw+o23th1qxZLFy4kFGjRnH//fdTWVnJ77//zu7du41mju7YsYOff/6ZRx99FGdnZz744AMmTZpEamqq4TN2fV8rYWKKEGb01VdfKUCNN1tbW8N5SUlJCqB4e3sreXl5huNz5sxRACU6OlqpqKgwHL/zzjsVGxsbpbS01HAsJCREAZRly5YZjuXn5yv+/v5KTEyM4dirr76qODo6KqdPnzaK9R//+Iei0WiU1NRURVEUZcWKFQqgvPXWW4ZzKisrlf79+yuA8tVXXxmOd+nSRfH39zeKff369QqghISEGF0HUF5++WXDzy+//LICKPfdd5/Rebfddpvi6elp+PnAgQMKoDz11FNG582YMaNamzXR/47ffvvta57z/vvvK4Dy3XffGY6Vl5crvXv3VpycnJSCggJFURTlySefVFxcXJTKysprthUdHa2MGTPmujHV5KmnnlIA5ffffzccu3z5stK6dWslNDRU0Wq1iqIoymeffaYAytGjR40eHxUVpQwZMsTwc21fb/3vx8XFRcnOzq5VrPr3XE23N954w3De9OnTFUB5/PHHDcd0Op0yZswYxcbGRrlw4YKiKH++51577TWj69x+++2KSqVSzpw5oyiKoiQkJChqtVq57bbbDL+Pq9v9a3zbt283HMvOzlZsbW2VZ555xnCsvq+VEKL5ys/PVwBl/PjxtX5MSEiIMn36dMPPpaWl1f4GJSUlKba2tsr8+fMNx8aPH6906NDhum27uroqs2fPvu4506dPr9anhoSEVPv7pf97fnU/PWDAAMXZ2VlJSUkxOvfqv5nFxcXVrrlr1y4FUL755hvDsZ9++kkBlC1btlQ7f+DAgcrAgQMNP9e2X9XH7OnpqeTm5hrOXblypQIov/76a/VfyFW2bNmiAMpPP/10zXNq27+a6vWqyYQJExQbGxvl7NmzhmPnz59XnJ2dlQEDBhiOzZkzR7G2tjb6XZSVlSlubm5Gn5dmzZql+Pv7KxcvXjS6zh133KG4uroaXlP97ycsLKzG17km1+rfAeXHH380nDdw4EAFUN59912jWLt06aL4+Pgo5eXliqLU/r2wefNmBVCeeOKJajFd/X4FFBsbG8NnA0VRlMOHDyuA8uGHHxqO1fe1EqYl08tFo/j444/ZsGGD0W3NmjXVzps8eTKurq6Gn3v16gXAPffcY1R8rFevXpSXl5Oenm70+ICAAMM3tVD1TeS0adM4dOgQmZmZAPz000/0798fd3d3Ll68aLjFxsai1WrZvn07AKtXr8bKyopHHnnE0J5Go+Hxxx83umZGRgZxcXFMnz7dKPZhw4ZVW2d2PX+thNm/f39ycnIMU5/004UeffRRo/P+Gk9DrF69Gj8/P+68807DMWtra5544gkKCwvZtm0bAG5ubhQVFV13+rGbmxvHjx8nISGhzjH07NmTfv36GY45OTnx4IMPkpycbJjuPXHiRKysrFi8eLHhvGPHjnHixAmmTp1qOFbb11tv0qRJeHt71zreXr16VXtv62cC/NXVW3vov5UvLy9n48aNhueu0Wh44oknjB73zDPPoCiK4f/MihUr0Ol0zJ07t9paNJVKZfRzVFQU/fv3N/zs7e1Nu3btSExMNByr72slhGi+9H2Ls7NzvduwtbU1/A3SarXk5OTg5OREu3btjKauurm5ce7cuetOk3Zzc2PPnj2cP3++3vFcy4ULF9i+fTv33XcfrVq1Mrrv6r+ZV89OqqioICcnh7Zt2+Lm5lbvqbi17Vf1pk6diru7u+Fn/d/vq/9m11dt+1dzvV5arZb169czYcIEwsLCDMf9/f2566672LFjh+F9OXXqVCoqKoyWCK5fv568vDxDH68oCsuWLWPcuHEoimLUx48YMYL8/Pxqr9v06dONXucbGT9+fI19/ODBg43Os7Ky4qGHHjL8bGNjw0MPPUR2djYHDhwAav9eWLZsGSqVqtpMPqjex8fGxtKmTRvDz507d8bFxaVaH2+u/1ui9iTpFo2iZ8+exMbGGt3++gcLqNYZ6pPY4ODgGo9funTJ6Hjbtm2r/UHSV5jUr8lKSEhg7dq1eHt7G91iY2OBqvU2ULW2y9/fHycnJ6P22rVrZ/RzSkoKAOHh4dWez1/PvZ6/Pnd9p6t/jikpKajV6mpV4E1ZAT4lJYXw8PBqiZx+2pz+uT766KNEREQwatQogoKCuO+++6qtIZo/fz55eXlERETQqVMnnnvuOY4cOVKrGGr6vf01Bi8vL4YOHcqSJUsM5yxevBgrKysmTpxoOFbb11uvpir71+Pl5VXtvR0bG0tISIjReWq12uhDBlR/b6akpBAQEFDtQ/Bfn/vZs2dRq9W1+lLnr+8rqHpvXf1/p76vlRCi+XJxcQGq1nvWl06n47333iM8PBxbW1u8vLzw9vbmyJEj5OfnG877+9//jpOTEz179iQ8PJzZs2fzxx9/GLX11ltvcezYMYKDg+nZsyfz5s0zSaIJfyasHTt2vO55JSUlzJ0711BTQ/988vLyjJ5PXdS2X9W70WeBhqht/2qu1+vChQsUFxdfMwadTkdaWhoA0dHRtG/f3uiL9cWLF+Pl5cWQIUMM7eXl5fH5559X6+NnzpwJNLyPDwoKqrGP9/X1NTovICAAR0dHo2M19fG1eS+cPXuWgICAGy5vg9r18eb8vyVqT5Ju0aRoNJo6HVdqKC51IzqdjmHDhtX4zeWGDRuYNGlSnds0BVM+R3Pz8fEhLi6OX375xbAGedSoUUZrrwYMGMDZs2dZsGABHTt25Msvv6Rr1658+eWXJovjjjvu4PTp08TFxQGwZMkShg4dipeXl+Gcur7edfkGvDmozfuqMV4rIUTT4uLiQkBAAMeOHat3G6+//jpPP/00AwYM4LvvvmPdunVs2LCBDh06GBWqjIyM5NSpUyxatIh+/fqxbNky+vXrZzSSN2XKFBITE/nwww8JCAjg7bffpkOHDjXOijOXxx9/nH/9619MmTKFJUuWsH79ejZs2ICnp2e1Qqvm0hQ+CzSV12vq1Kls2bKFixcvUlZWxi+//MKkSZMMMx/1r8k999xzzT6+b9++Rm3ejH18U/i/JaSQmmhhzpw5g6IoRqPdp0+fBjBUPG3Tpg2FhYWGkc5rCQkJYdOmTRQWFhqNdp86daraeUCNU3P/em5DhISEoNPpSEpKMhpVP3PmjEmvceTIEXQ6ndE3sSdPnjTcr2djY8O4ceMYN24cOp2ORx99lM8++4yXXnrJMPru4eHBzJkzmTlzJoWFhQwYMIB58+Zx//33XzeGmn5vNcUwYcIEHnroIcM34adPn2bOnDlGj6vt621uOp2OxMREo709//reDAkJYePGjVy+fNlotPuvz71NmzbodDpOnDhBly5dTBJffV4rIUTzNnbsWD7//HN27dpF79696/z4pUuXMnjwYP7v//7P6HheXp7Rl59QVVxy6tSpTJ06lfLyciZOnMi//vUv5syZY9jey9/fn0cffZRHH32U7Oxsunbtyr/+9S9GjRpV/ycJhllGN/qCYenSpUyfPp13333XcKy0tLTariV/nVF3PXXpV82tLv2rOV4vb29vHBwcrhmDWq02mtk4depUXnnlFZYtW4avry8FBQXccccdRu05Ozuj1Wot3sefP3+eoqIio9Humvr42rwX2rRpw7p168jNza3VaHdtmOv/lqg9GekWLcr58+eNtuoqKCjgm2++oUuXLvj5+QFV3/jt2rWLdevWVXt8Xl4elZWVAIwePZrKykr+97//Ge7XarV8+OGHRo/x9/enS5cufP3110bTzzZs2GCS7ab09JU6P/nkE6Pjf42nIUaPHk1mZqbRdK7Kyko+/PBDnJycGDhwIAA5OTlGj1Or1XTu3BmAsrKyGs9xcnKibdu2hvuvF8PevXvZtWuX4VhRURGff/45oaGhRlOq3dzcGDFiBEuWLGHRokXY2NgwYcIEo/Zq+3o3hqu3MVMUhY8++ghra2uGDh0KVD13rVZrdB7Ae++9h0qlMnSOEyZMQK1WM3/+/GqjL/UZDanvayWEaN6ef/55HB0duf/++8nKyqp2/9mzZ422gvwrjUZT7W/OTz/9VK3eyl//xtjY2BAVFYWiKFRUVKDVaqtN3/bx8SEgIMAkf4e8vb0ZMGAACxYsIDU11ei+q+Ov6fl8+OGHaLVao2P6xOpaW4herbb9amOobf9qrtdLo9EwfPhwVq5cabQNW1ZWFj/88AP9+vUzLHuAqhH3Tp06sXjxYhYvXoy/vz8DBgwwam/SpEksW7asxi9Uaqpiby6VlZV89tlnhp/Ly8v57LPP8Pb2plu3bkDt3wuTJk1CUZQat0Wtax9v7v9bovZkpFs0ijVr1hi+ybtanz59qq1zbYiIiAhmzZrFvn378PX1ZcGCBWRlZfHVV18Zznnuuef45ZdfGDt2rGHrpKKiIo4ePcrSpUtJTk7Gy8uLcePG0bdvX/7xj3+QnJxs2PO7pnVdb7zxBmPGjKFfv37cd9995ObmGva4LCwsNMlz69atG5MmTeL9998nJyfHsGWY/pvU2n7zvmnTJkpLS6sdnzBhAg8++CCfffYZM2bM4MCBA4SGhrJ06VL++OMP3n//fcPo6/33309ubi5DhgwhKCiIlJQUPvzwQ7p06WJYmxQVFcWgQYPo1q0bHh4e7N+/37BlxfX84x//4Mcff2TUqFE88cQTeHh48PXXX5OUlMSyZcuqrYWaOnUq99xzD5988gkjRozAzc3N6P7avt71lZ6eznfffVftuJOTk9EXAHZ2dqxdu5bp06fTq1cv1qxZw6pVq/jnP/9pKNw2btw4Bg8ezAsvvEBycjLR0dGsX7+elStX8tRTTxmKpbRt25YXXniBV199lf79+zNx4kRsbW3Zt28fAQEBvPHGG3V6DvV9rYQQzVubNm344YcfmDp1KpGRkUybNo2OHTtSXl7Ozp07DdsZXcvYsWOZP38+M2fOpE+fPhw9epTvv/++Wr8+fPhw/Pz86Nu3L76+vsTHx/PRRx8xZswYnJ2dycvLIygoiNtvv53o6GicnJzYuHEj+/btMxp1bogPPviAfv360bVrVx588EFat25NcnIyq1atMixRGjt2LN9++y2urq5ERUWxa9cuNm7cWG170y5duqDRaHjzzTfJz8/H1taWIUOG4OPjU+26te1XTWXZsmU1ft6aPn16rftXc75er732Ghs2bKBfv348+uijWFlZ8dlnn1FWVsZbb71V7fypU6cyd+5c7OzsmDVrVrXPAP/+97/ZsmULvXr14oEHHiAqKorc3FwOHjzIxo0byc3NbcBvs2q0uqY+3tfX12hLzYCAAN58802Sk5OJiIhg8eLFxMXF8fnnnxu2eqvte2Hw4MHce++9fPDBByQkJDBy5Eh0Oh2///47gwcPrlPffPnyZbP/3xK11Njl0sXN5XpbhnHVdh7X2s7qWltg6Nvdt2+f4Zh+25B169YpnTt3VmxtbZX27dvXuH3G5cuXlTlz5iht27ZVbGxsFC8vL6VPnz7KO++8Y9jaQVEUJScnR7n33nsVFxcXxdXVVbn33nuVQ4cOVduKRFEUZdmyZUpkZKRia2urREVFKT///HON25twjS3D9NtG/fU5JiUlGY4VFRUps2fPVjw8PBQnJydlwoQJyqlTpxRA+fe//32tl0FRlD9/x9e6ffvtt4qiKEpWVpYyc+ZMxcvLS7GxsVE6depU7bkuXbpUGT58uOLj46PY2NgorVq1Uh566CElIyPDcM5rr72m9OzZU3Fzc1Ps7e2V9u3bK//617+Mfr/XcvbsWeX2229X3NzcFDs7O6Vnz57Kb7/9VuO5BQUFir29fbVtOK5Wm9e7Nluq/dX1tgy7+nWfPn264ujoqJw9e1YZPny44uDgoPj6+iovv/xyte12Ll++rPztb39TAgICFGtrayU8PFx5++23jbYJ0VuwYIESExOj2NraKu7u7srAgQOVDRs2GMVX01Zgf93SpiGvlRCi+Tt9+rTywAMPKKGhoYqNjY3i7Oys9O3bV/nwww+rbc351y3DnnnmGcXf31+xt7dX+vbtq+zatava35jPPvtMGTBggOLp6anY2toqbdq0UZ577jklPz9fUZSq7ZWee+45JTo6WnF2dlYcHR2V6Oho5ZNPPjGKsyFbhimKohw7dky57bbbDH1Lu3btlJdeeslw/6VLlwz9n5OTkzJixAjl5MmT1Z63oijKF198oYSFhSkajcZo+7C/PndFqV2/er0+6K+fG2qi/7x0rZt+m7Da9K+mer2u5eDBg8qIESMUJycnxcHBQRk8eLCyc+fOGs9NSEgwPIcdO3bUeE5WVpYye/ZsJTg4WLG2tlb8/PyUoUOHKp9//nm138/1tlT7q+v9Pq9+jQcOHKh06NBB2b9/v9K7d2/Fzs5OCQkJUT766KMaY73Re0FRqraoffvtt5X27dsrNjY2ire3tzJq1CjlwIEDRvHVtBXY1e/Xhr5WwnRUitIEqzQJIWotLi6OmJgYvvvuO+6++25LhyNqMGPGDJYuXWqyWQ9CCCGEaBoGDRrExYsXG1SUULR8sqZbiGakpKSk2rH3338ftVpttM5JCCGEEEII0TTImm4hmpG33nqLAwcOMHjwYKysrFizZg1r1qzhwQcfrLaXuRBCCCGEEMLyJOkWohnp06cPGzZs4NVXX6WwsJBWrVoxb948XnjhBUuHJoQQQgghhKiBrOkWQgghhBBCCCHMRNZ0CyGEEEIIIYQQZiJJtxBCCCGEEEIIYSY33ZpunU7H+fPncXZ2RqVSWTocIYQQNzlFUbh8+TIBAQGo1fJd+PVIHy6EEKIpqW0fftMl3efPn5cqz0IIIZqctLQ0goKCLB1GkyZ9uBBCiKboRn34TZd0Ozs7A1W/GBcXFwtHI4QQ4mZXUFBAcHCwoX8S1yZ9uBBCiKaktn34TZd066ejubi4SIcthBCiyZDp0jcmfbgQQoim6EZ9uCweE0IIIYQQQgghzESSbiGEEEIIIYQQwkwk6RZCCCGEEEIIIczkplvTLYQQ16LT6SgvL7d0GKKFsba2RqPRWDoMIYRo0aQPF+Zgqj5ckm4hhADKy8tJSkpCp9NZOhTRArm5ueHn5yfF0oQQwgykDxfmZIo+XJJuIcRNT1EUMjIy0Gg0BAcHo1bLyhthGoqiUFxcTHZ2NgD+/v4WjkgIIVoW6cOFuZiyD5ekWwhx06usrKS4uJiAgAAcHBwsHY5oYezt7QHIzs7Gx8dHppoLIYQJSR8uzMlUfbh8FSSEuOlptVoAbGxsLByJaKn0HwQrKiosHIkQQrQs0ocLczNFHy5JtxBCXCHrbYW5yHtLCCHMS/7OCnMxxXtLkm4hhBBCCCGEEMJMJOkWQghhEBoayvvvv2/pMIQQQghRR9KHN12SdAshRDOkUqmue5s3b1692t23bx8PPvhgg2IbNGgQTz31VIPaEEIIIVoq6cNvPlK9XAghmqGMjAzDvxcvXszcuXM5deqU4ZiTk5Ph34qioNVqsbK68Z98b29v0wYqhBBCCCPSh998ZKRbCCGaIT8/P8PN1dUVlUpl+PnkyZM4OzuzZs0aunXrhq2tLTt27ODs2bOMHz8eX19fnJyc6NGjBxs3bjRq969T01QqFV9++SW33XYbDg4OhIeH88svvzQo9mXLltGhQwdsbW0JDQ3l3XffNbr/k08+ITw8HDs7O3x9fbn99tsN9y1dupROnTphb2+Pp6cnsbGxFBUVNSgeIYQQojFJH37z9eGSdDdASWkZn3+znNKyckuHIoQwIUVRqKjUWuSmKIrJnsc//vEP/v3vfxMfH0/nzp0pLCxk9OjRbNq0iUOHDjFy5EjGjRtHamrqddt55ZVXmDJlCkeOHGH06NHcfffd5Obm1iumAwcOMGXKFO644w6OHj3KvHnzeOmll1i4cCEA+/fv54knnmD+/PmcOnWKtWvXMmDAAKBqZODOO+/kvvvuIz4+nq1btzJx4kST/s7EzSPvcgnHEzIoKZVt3IRoSaQPNyZ9eNMg08vrSVEUnn35fQ4eOUl+wWWee2yapUMSQphIpVbH//202yLXnjX5FqytNCZpa/78+QwbNszws4eHB9HR0YafX331VZYvX84vv/zCY489ds12ZsyYwZ133gnA66+/zgcffMDevXsZOXJknWP6z3/+w9ChQ3nppZcAiIiI4MSJE7z99tvMmDGD1NRUHB0dGTt2LM7OzoSEhBATEwNUddiVlZVMnDiRkJAQADp16lTnGIQA2LDjFDl5RdhYWxEeKlMyhWgppA83Jn140yAj3fWkUqmYNmUMAD+v2sKWHfstHJEQQhjr3r270c+FhYU8++yzREZG4ubmhpOTE/Hx8Tf8lrxz586Gfzs6OuLi4kJ2dna9YoqPj6dv375Gx/r27UtCQgJarZZhw4YREhJCWFgY9957L99//z3FxcUAREdHM3ToUDp16sTkyZP54osvuHTpUr3iECLIzxWA9Kw8ywYihBA1kD68ZZGR7gbo1a0j904ezbc/reb19xfQPjwUf18vS4clhGggK42aWZNvsdi1TcXR0dHo52effZYNGzbwzjvv0LZtW+zt7bn99tspL7/+Ehlra2ujn1UqFTqdzmRxXs3Z2ZmDBw+ydetW1q9fz9y5c5k3bx779u3Dzc2NDRs2sHPnTtavX8+HH37ICy+8wJ49e2jdurVZ4hEtV6CvG4dPnudcZj6KoqBSqSwdkhDCBKQPNyZ9eNMgI90N9OC02+jYvg2FRSXM/fenVFZWWjokIUQDqVQqrK00FrmZ84P/H3/8wYwZM7jtttvo1KkTfn5+JCcnm+16NYmMjOSPP/6oFldERAQaTdWUPCsrK2JjY3nrrbc4cuQIycnJbN68Gah6bfr27csrr7zCoUOHsLGxYfny5Y36HETL4O/jglqtorC4jILCUkuHI4QwEenDzUf68PqTke4GsrKyYv4/Hmba7LkcO3mWz79dzqMzJ1s6LCGEqCY8PJyff/6ZcePGoVKpeOmll8z2bfeFCxeIi4szOubv788zzzxDjx49ePXVV5k6dSq7du3io48+4pNPPgHgt99+IzExkQEDBuDu7s7q1avR6XS0a9eOPXv2sGnTJoYPH46Pjw979uzhwoULREZGmuU5iJbN2kqDr5czGdkFnMvMw9XZ3tIhCSHENUkf3rzJSLcJ+Pt6MefJmQB8u2Q1ew4cs3BEQghR3X/+8x/c3d3p06cP48aNY8SIEXTt2tUs1/rhhx+IiYkxun3xxRd07dqVJUuWsGjRIjp27MjcuXOZP38+M2bMAMDNzY2ff/6ZIUOGEBkZyaeffsqPP/5Ihw4dcHFxYfv27YwePZqIiAhefPFF3n33XUaNGmWW5yBaviBfNwDSs/ItG4gQQtyA9OHNm0q5Weq0X1FQUICrqyv5+fm4uLiYtO23PvyG5au34O7mwrcfz8fTw9Wk7QshzKO0tJSkpCRat26NnZ2dpcMRLdD13mPm7JdaGlP/rjIvFrBiw1FsbayYfltP1GpZ1y1EcyN9uDA3U/ThMtJtQk88eAdhoYFcyitg/jtfmG3KhxBCCCEazsfDGWsrDWXlleTkFVk6HCGEEC2UJN0mZGdrw2v/eARbWxv2HjrO90vXWDokIYQQQlyDWq0iwLdqZOJcZp5lgxFCCNFiSdJtYq1DAnn6kbsB+Ozrnzkaf8bCEQkhhBDiWmRdtxBCCHOTpNsMxg3vz7CBvdDqdMz996cUXJYpa0IIIZqfjz/+mNDQUOzs7OjVqxd79+697vl5eXnMnj0bf39/bG1tiYiIYPXq1Yb7582bh0qlMrq1b9/e3E/jugL93ADIuFBApVaWhQkhhDA9SbrNQKVS8ffHpxPo501mdg7//u9CbrJ6dUIIIZq5xYsX8/TTT/Pyyy9z8OBBoqOjGTFiBNnZ2TWeX15ezrBhw0hOTmbp0qWcOnWKL774gsDAQKPzOnToQEZGhuG2Y8eOxng61+TuYo+DvTVarY6sCwUWjUUIIUTLJEm3mTg62vPqnEewstKw5Y/9LF+91dIhCSGEELX2n//8hwceeICZM2cSFRXFp59+ioODAwsWLKjx/AULFpCbm8uKFSvo27cvoaGhDBw4kOjoaKPzrKys8PPzM9y8vLwa4+lck0qlIvDKFPNzMsVcCCGEGUjSbUaREa15dOZkAP772Q+cSUqzcERCCCHEjZWXl3PgwAFiY2MNx9RqNbGxsezatavGx/zyyy/07t2b2bNn4+vrS8eOHXn99dfRarVG5yUkJBAQEEBYWBh33303qamp14yjrKyMgoICo5s5/LmuO88s7QshhLi5SdJtZlMnDKNPj86UV1Ty0hufUlJaZumQhBBCiOu6ePEiWq0WX19fo+O+vr5kZmbW+JjExESWLl2KVqtl9erVvPTSS7z77ru89tprhnN69erFwoULWbt2Lf/73/9ISkqif//+XL58ucY233jjDVxdXQ234OBg0z3JqwT6uQJwIbeQsvJKs1xDCCHEzUuSbjNTq9W8+PQsvDzcSE47z3uffm/pkIQQQgiT0+l0+Pj48Pnnn9OtWzemTp3KCy+8wKeffmo4Z9SoUUyePJnOnTszYsQIVq9eTV5eHkuWLKmxzTlz5pCfn2+4paWZZ8aYk4Mtbs72KAqcz5Yp5kIIIUxLku5G4O7mwrznH0SlUvHrut9Zv3W3pUMSQggABg0axFNPPWX4OTQ0lPfff/+6j1GpVKxYsaLB1zZVO8L0vLy80Gg0ZGVlGR3PysrCz8+vxsf4+/sTERGBRqMxHIuMjCQzM5Py8vIaH+Pm5kZERARnztS8vaatrS0uLi5GN3PRj3bLft1CiOZC+vDmQ5LuRtItOpIZd4wD4M0Pvubc+ZqrvwohRG2MGzeOkSNH1njf77//jkql4siRI3Vud9++fTz44IMNDc/IvHnz6NKlS7XjGRkZjBo1yqTX+quFCxfi5uZm1mu0RDY2NnTr1o1NmzYZjul0OjZt2kTv3r1rfEzfvn05c+YMOt2f226dPn0af39/bGxsanxMYWEhZ8+exd/f37RPoB6Crmwdlp4pI91CCPOSPrx2WlIfLkl3I7rv7lvp0jGC4pJS5v77f1RUyLoxIUT9zJo1iw0bNnDu3Llq93311Vd0796dzp0717ldb29vHBwcTBHiDfn5+WFra9so1xJ19/TTT/PFF1/w9ddfEx8fzyOPPEJRUREzZ84EYNq0acyZM8dw/iOPPEJubi5PPvkkp0+fZtWqVbz++uvMnj3bcM6zzz7Ltm3bSE5OZufOndx2221oNBruvPPORn9+fxXg44pKBXmXSygslvorQgjzkT785iNJdyOy0miY9/yDuDg7Ep+QzP8WLrV0SEKIZmrs2LF4e3uzcOFCo+OFhYX89NNPzJo1i5ycHO68804CAwNxcHCgU6dO/Pjjj9dt969T0xISEhgwYAB2dnZERUWxYcOGao/5+9//TkREBA4ODoSFhfHSSy9RUVEBVH1L/corr3D48GFUKhUqlcoQ81+nph09epQhQ4Zgb2+Pp6cnDz74IIWFhYb7Z8yYwYQJE3jnnXfw9/fH09OT2bNnG65VH6mpqYwfPx4nJydcXFyYMmWK0ZTqw4cPM3jwYJydnXFxcaFbt27s378fgJSUFMaNG4e7uzuOjo506NCB1atX1zuWpmbq1Km88847zJ07ly5duhAXF8fatWsNxdVSU1PJyMgwnB8cHMy6devYt28fnTt35oknnuDJJ5/kH//4h+Gcc+fOceedd9KuXTumTJmCp6cnu3fvxtvbu9Gf31/Z2ljh7eEEyGi3EMK8pA+/+fpwK7O1LGrk6+3Ji0/P4vlXPuDHn9fRLTqSvj2jb/xAIUSjURSF0rKa16Cam52tDSqV6obnWVlZMW3aNBYuXMgLL7xgeMxPP/2EVqvlzjvvpLCwkG7duvH3v/8dFxcXVq1axb333kubNm3o2bPnDa+h0+mYOHEivr6+7Nmzh/z8fKO1Y3rOzs4sXLiQgIAAjh49ygMPPICzszPPP/88U6dO5dixY6xdu5aNGzcC4OrqWq2NoqIiRowYQe/evdm3bx/Z2dncf//9PPbYY0YfSrZs2YK/vz9btmzhzJkzTJ06lS5duvDAAw/c8PnU9Pz0nfW2bduorKxk9uzZTJ06la1btwJw9913ExMTw//+9z80Gg1xcXFYW1sDMHv2bMrLy9m+fTuOjo6cOHECJyenOsfRlD322GM89thjNd6n/x1drXfv3uzefe26JYsWLTJVaGYR6OtGdk4h57LyaBfmY+lwhBD1IH14FenDm1YfLkm3BfS/JYYp42NZsnIjr737JV9/PB8fL3dLhyWEuKK0rJwhtz1skWtvXv4p9na1m65133338fbbb7Nt2zYGDRoEVE1LmzRpkmGLpWeffdZw/uOPP866detYsmRJrTrsjRs3cvLkSdatW0dAQAAAr7/+erU1XC+++KLh36GhoTz77LMsWrSI559/Hnt7e5ycnLCysrpmAS6AH374gdLSUr755hscHR0B+Oijjxg3bhxvvvmmYXTV3d2djz76CI1GQ/v27RkzZgybNm2qV4e9adMmjh49SlJSkmErqm+++YYOHTqwb98+evToQWpqKs899xzt27cHIDw83PD41NRUJk2aRKdOnQAICwurcwyiaQnydeXQiXOkZ+ahKEqtPjwLIZoW6cOrSB/etPpwmV5uIbPvm0JEm1bkFRTyytufo9XqbvwgcUOJKel8+OViiktKLR2KEGbXvn17+vTpw4IFCwA4c+YMv//+O7NmzQJAq9Xy6quv0qlTJzw8PHBycmLdunWkpqbWqv34+HiCg4MNnTVQYxGtxYsX07dvX/z8/HBycuLFF1+s9TWuvlZ0dLShs4aqwlw6nY5Tp04ZjnXo0MGoOra/vz/Z2fUrTKl/flfv/RwVFYWbmxvx8fFA1brm+++/n9jYWP79739z9uxZw7lPPPEEr732Gn379uXll1+uV9Eb0bT4erug0agpLq3gUkGJpcMRQrRg0offXH24jHRbiI2NNa/+4xFmPD6Pg0dO8vXi37jvrlstHVaz98Z/v+JY/Fl8vNyZOmG4pcMRzZSdrQ2bl3964xPNdO26mDVrFo8//jgff/wxX331FW3atGHgwIEAvP322/z3v//l/fffp1OnTjg6OvLUU09dc/um+ti1axd33303r7zyCiNGjMDV1ZVFixbx7rvvmuwaV9NPC9NTqVRG1bJNbd68edx1112sWrWKNWvW8PLLL7No0SJuu+027r//fkaMGMGqVatYv349b7zxBu+++y6PP/642eIR5mWlUePv7cK5zDzSM/PwcG2cgkRCCNORPrz2pA9vvD5cRrotqFWQH88/Pg2A//t+BXHHTls4oubtfOYFjsVXfYOVlHrewtGI5kylUmFvZ2uRW12ns06ZMgW1Ws0PP/zAN998w3333Wdo448//mD8+PHcc889REdHExYWxunTtf87ExkZSVpamlGxrL+u1925cychISG88MILdO/enfDwcFJSUozOsbGxQavV3vBahw8fpqioyHDsjz/+QK1W065du1rHXBf655eWlmY4duLECfLy8oiKijIci4iI4G9/+xvr169n4sSJfPXVV4b7goODefjhh/n555955pln+OKLL8wSq2g8gb5X9uvOyrNsIEKIepE+vIr04VWaSh8uSbeFjRzSh9GxfdHpFF5+81PyCwpv/CBRow3b9hj+nZKWacFIhGg8Tk5OTJ06lTlz5pCRkcGMGTMM94WHh7NhwwZ27txJfHw8Dz30kFFVzxuJjY0lIiKC6dOnc/jwYX7//XdeeOEFo3PCw8NJTU1l0aJFnD17lg8++IDly5cbnRMaGkpSUhJxcXFcvHiRsrLq2zHdfffd2NnZMX36dI4dO8aWLVt4/PHHuffeew1rwepLq9USFxdndIuPjyc2NpZOnTpx9913c/DgQfbu3cu0adMYOHAg3bt3p6SkhMcee4ytW7eSkpLCH3/8wb59+4iMjATgqaeeYt26dSQlJXHw4EG2bNliuE80X/r9us9nFaDTKZYNRgjRokkffmMtpQ+XpLsJeObRe2gV6Ef2xUu89p//Q1Gkk6+P9Vv//PYu5VzGdc4UomWZNWsWly5dYsSIEUZrt1588UW6du3KiBEjGDRoEH5+fkyYMKHW7arVapYvX05JSQk9e/bk/vvv51//+pfRObfeeit/+9vfeOyxx+jSpQs7d+7kpZdeMjpn0qRJjBw5ksGDB+Pt7V3jlicODg6sW7eO3NxcevTowe23387QoUP56KOP6vbLqEFhYSExMTFGt3HjxqFSqVi5ciXu7u4MGDCA2NhYwsLCWLx4MQAajYacnBymTZtGREQEU6ZMYdSoUbzyyitA1QeB2bNnExkZyciRI4mIiOCTTz5pcLzCsjzdHLG1saKiUkt27mVLhyOEaOGkD7++ltKHq5SbLMMrKCjA1dWV/Px8XFxcLB2Owemzqdz/1KtUVFby3GPTmDhmsKVDalbOJKVx76NzsbLSUFlZNQVm3ZKPcHF2vMEjhYDS0lKSkpJo3bo1dnZ2lg5HtEDXe4811X6pKWqs39X6HSdJTMuhR6dWdOsYfOMHCCEsRvpwYW6m6MNlpLuJiGjTigenTwRg1YYdFo6m+dFPLe/TIxpvz6rt11LPyRRzIYQQdSfruoUQQpiSJN1NyLCBVXvunUpIpqhYtiqpLUVR2LC1KukeNqgXIcH+gEwxF0IIUT/6dd1ZFy9TUXn9AkJCCCHEjUjS3QCXi8o4fDKdvMumSZB9vT3x9/VCq9NxNP6MSdq8GRw7eZaMrIs42NvRr2c0rYL8AEhJk6RbCCFE3bk42eHkYItOp5CRXWDpcIQQQjRzknQ3wO/7z7LrUDJnUi6YrM2YTlVl9eOOyvZhtaUf5R7QOwY7O1tCg/Qj3TK9XAghRN2pVCqC/KqmmKfLFHMhhBANJEl3A4QFewKQmJpjsjb1Sfeho6dM1mZLVqnVsnH7XgCGD7oFQKaXCyGEaLBAXzcAzmXmWzYQIYQQzZ4k3Q0QGuiBWqUiN7+YvIJik7TZpWNV0n3idCKlZeUmabMlO3j4JJfyCnB1caJHTBSAYXr5ufPZVFZWWjI80czcZJs5iEak0+ksHYKoI30xtZy8IkpKKywcjRDiRqQPF+Ziij7cygRx3LTsbK0J9HUlLTOPxLQcunZwaHCbgf7eeHu6cyHnEsdPnqVbtPk2aW8J9HtzD+3fAyurqrezj5c7drY2lJaVcz7zoiEJF+JarK2tUalUXLhwAW9vb1QqlaVDEi2EoiiUl5dz4cIF1Go1NjY2lg5J1JKDvQ0erg7k5heTnp1P21Zelg5JCFED6cOFuZiyD5eku4HCWnlelXQ3fC9PlUpFl04RbNi6h0NHT0nSfR1l5RVs/eMA8OfUcgC1Wk2rID9On00l5VyGJN3ihjQaDUFBQZw7d47k5GRLhyNaIAcHB1q1aoVaLRPMmpMgP7eqpDszT5JuIZoo6cOFuZmiD5eku4FCgzzZvu8sFy8VkX+5BFdn+wa3GdOpHRu27iHumKzrvp5d+w5TVFyCr7cHnaLaGt0XEuxflXSnZdD/lhgLRSiaEycnJ8LDw6mokGmkwrQ0Gg1WVlYy+tIMBfq5cuTUec5l5lk6FCHEdUgfLszFVH24JN0NZG9rTYCPK+lZ+SSm5RATFdTgNmM6tQfgaPxZyssrsLGxbnCbLdF6/d7cA3tV++YpRL9tmFQwF3Wg0WjQaDSWDkMI0UQEeLuiVqm4XFRGQWEpLk52lg5JCHEN0oeLpkzmuZmAoYp5mmmqmIcE+eHu5kJ5eQXxp5NM0mZLU1RUwh974gAYdtXUcr2QIKlgLoQQomGsrTX4eDkDyGi3EEKIerNo0r19+3bGjRtHQEAAKpWKFStWXPf8n3/+mWHDhuHt7Y2Liwu9e/dm3bp1jRPsdbQOqkq6L+QWcrmotMHtqVQqunSMAODQMdmvuybbdh2kvKKS0OAAwsOqr6XXbxuWnJoh1SyFEELUW5Cv7NcthBCiYSyadBcVFREdHc3HH39cq/O3b9/OsGHDWL16NQcOHGDw4MGMGzeOQ4cOmTnS63Owt8HfxwUw3Wi3fr/uuKMnTdJeS6OvWj5sUK8a11gEB/gCcLmwiLz8y40amxBCiJYj0M8NgPSsfPkSVwghRL1YdE33qFGjGDVqVK3Pf//9941+fv3111m5ciW//vorMTGWLZbVJtiLjOwCEtNyiG4f2OD29En3kRNnqKysNGyHJSA3r4D9h04AVUl3TezsbPHz8SQzO4fUc5m4u7k0ZohCCCFaCB9PJ6yt1JSWVZKTV4SXu5OlQxJCCNHMNOs13TqdjsuXL+Ph4XHNc8rKyigoKDC6mUProKoYsi5eprC4rMHthYUE4uzkSElpGafOpja4vZZk8+/70Op0REa0Noxo10Q/xVzWdQshhKgvjVqNv0/VFPNzmfkWjkYIIURz1KyT7nfeeYfCwkKmTJlyzXPeeOMNXF1dDbfg4IbvpV0TRwdb/K4UW0kywRRztVpNl47hABw6KluHXU0/tXx4DQXUrqavYJ6cJkm3EEKI+guUdd1CCCEaoNkm3T/88AOvvPIKS5YswcfH55rnzZkzh/z8fMMtLS3NbDGFBXsBplzXXbV1WJwk3QYZWRc5euIMKpWKoQN6XPdcfQXzVNk2TAghRAMEXVnXnZFdgFars2wwQgghmp1mmXQvWrSI+++/nyVLlhAbG3vdc21tbXFxcTG6mUvrK1uHZVwooKikvMHt6dd1Hz5+Wjr5KzZsq9qbu2vn9nh7ul/3XJleLoQQwhQ8XB2wt7WmUqsjK0eKcwohhKibZpd0//jjj8ycOZMff/yRMWPGWDocI86Otvh4VhVYSTrX8NHutmHBONjbUVhUwpkk843QNycbtlYl3cOvUUDtavqk+3zmBcrLK8walxBCiJZLpVIR6Hdlirns1y2EEKKOLJp0FxYWEhcXR1xcHABJSUnExcWRmlpVOGzOnDlMmzbNcP4PP/zAtGnTePfdd+nVqxeZmZlkZmaSn990CpsYppinNjzpttJoiO5Qta477phMMU9MSedMUhpWVhoG9e1+w/M93V1xsLdDp1M4l5HdCBEKIYRoqYJ83QA4l9V0PnMIIYRoHiyadO/fv5+YmBjDdl9PP/00MTExzJ07F4CMjAxDAg7w+eefU1lZyezZs/H39zfcnnzySYvEX5MwwxTzfEpKTTfFXIqpwYYrBdR6d++Ei7PjDc9XqVSG0e5UmWIuhBCiAfT7dWfnXKasvNKywQghhGhWLLr586BBg1AU5Zr3L1y40OjnrVu3mjcgE3BxssPbw5ELuUUkncslqq1fg9rrciXpjjt2Gp1Oh1rd7FYEmISiKFdNLb9+1fKrhQT7E386ieQ0KaYmhBCi/pwdbXFxsqOgsJSM7HxCgzwtHZIQQohm4ubM4MzMlFXM27cNxc7WhvyCwpt666sTpxJJz7yAvZ0t/Xp1qfXjQgKrvvSQYmpCCCEaSl/FXKaYCyGEqAtJus1AX8U8PSuP0rKGFfCytraiY2Rb4OaeYq7fm3tA7xjs7Gxr/bg/p5fLSLcQQoiGCZJiakIIIepBkm4zcHO2x9PNEUWB5HO5DW7vz3XdJxvcVnOk1erYuH0vULep5XDVtmFpGdddyiCEEELcSIBPVdJ9qaCEouIyC0cjhBCiuZCk20z0BdXOmmCKuT7pjjt6+qZMHA8ciSf3UgGuLk707NqhTo8N8vdBrVZRVFxCziWZDiiEEKL+7Gyt8faoKuSZLlPMhRBC1JIk3WYS1urPKeYNrXIa1S4MG2srci7lk5aeZYrwmhV9AbUh/XpgZVW32n82Ntb4+3oDMsVcCCFEwwXK1mFCCCHqSJJuM3F3ccDd1QGdTiE5vWFTzG1trIlq1wa4+fbrLiuvYOsf+wEYNqhXvdrQTzG/mQvRCSGEMA19MbX0zLybcvaZEEKIupOk24zaXJlinph2scFt3az7de/ad4TCohJ8vNyJ7hBerzZCgq5UMJekWwgh6uTjjz8mNDQUOzs7evXqxd69e697fl5eHrNnz8bf3x9bW1siIiJYvXp1g9psavy8nNGoVRSVlJN/ucTS4QghhGgGJOk2o7BWVVuHpWXkUV7RsCnmXTpFAFVJ9830zfqGbVVTy2MH9qr3HuUhQVeKqcm2YUIIUWuLFy/m6aef5uWXX+bgwYNER0czYsQIsrOzazy/vLycYcOGkZyczNKlSzl16hRffPEFgYGB9W6zKbKy0uDn7QLAuUyZYi6EEOLGJOk2I3cXe9xc7NHpFFLSLzWorU6RbdFoNGRdyCUzu+HF2ZqDoqISduyJA+petfxqsm2YEELU3X/+8x8eeOABZs6cSVRUFJ9++ikODg4sWLCgxvMXLFhAbm4uK1asoG/fvoSGhjJw4ECio6Pr3WZT9ee67jyLxiGEEKJ5kKTbjFQqlaGKeUOnmNvb2RIZHgrAwSM3x9Zh23cfory8glZBfkS0aVXvdvTTyzOzcygtlS1ehBDiRsrLyzlw4ACxsbGGY2q1mtjYWHbt2lXjY3755Rd69+7N7Nmz8fX1pWPHjrz++utotdp6t9lUBV7Zr/t8Vj463c0z+0wIIUT9SNJtZmHBVVPMUzPyqKjQNqitm21d9/qtu4GqUW6VSlXvdtxcnXF2ckRRFNLO33zV34UQoq4uXryIVqvF19fX6Livry+ZmTXPGkpMTGTp0qVotVpWr17NSy+9xLvvvstrr71W7zbLysooKCgwujUF3u5O2FhrKK/QcuFSoaXDEUII0cRJ0m1mnm4OuDjZodXqSMlo2BRzw37dx06bIrQm7VJeAfsOHgdgeD2rluupVCpCgq8UU5Mp5kIIYRY6nQ4fHx8+//xzunXrxtSpU3nhhRf49NNP693mG2+8gaurq+EWHBxswojrT61WEehbNdqdnpln2WCEEEI0eZJ0m5lKpfqzinlqw6aYd44KR61WkZ6RTfbFhiXwTd3mHfvR6nREhocSHOjX4PYMxdSkgrkQQtyQl5dXVR2RLOPZQVlZWfj51fw32d/fn4iICDQajeFYZGQkmZmZlJeX16vNOXPmkJ+fb7ilpaU18JmZjn5dd7rs1y2EEOIGJOluBPoq5qnnL1FRWf8p5o6O9kS0CQHg0NGWva57w5Wp5cMaUEDtaqHBUsFcCCFqy8bGhm7durFp0ybDMZ1Ox6ZNm+jdu3eNj+nbty9nzpxBp9MZjp0+fRp/f39sbGzq1aatrS0uLi5Gt6Yi6Mq67owLBQ3q24UQQrR8knQ3Ai93R5wdbanU6kjLyGtQW106Vm0d1pKnmGdm53D4eAIqlYqhA3qapM1WV4qpSQVzIYSonaeffpovvviCr7/+mvj4eB555BGKioqYOXMmANOmTWPOnDmG8x955BFyc3N58sknOX36NKtWreL1119n9uzZtW6zOXF1tsfRwQadTiHzwmVLhyOEEKIJs7J0ADcDfRXzwyfPk5h20VDRvD5iOrVj0fL1LbqY2sYre3PHdGqHj5e7SdrUbxuWkpaBTqer957fQghxs5g6dSoXLlxg7ty5ZGZm0qVLF9auXWsohJaammr0tzQ4OJh169bxt7/9jc6dOxMYGMiTTz7J3//+91q32ZyoVCoCfd04nZRNelYewf5ulg5JCCFEEyVJdyMJC/bi8MnzpKTnUqnVYaWpX9IXfWWkOyUtg9y8Ajzcms5UO1O5umq5qQT6eaPRaCgtK+dCziV8vev/xYcQQtwsHnvsMR577LEa79u6dWu1Y71792b37t31brO5CfJ1NSTdQgghxLXIcF8j8fF0wsnBhopKHecaUMXc1dmJNqFBAMQ18mh3ZWUlT/zzbWY+8YrZprcnpaSTkJiGlZWGQf26maxdKysrAv29AUhJkynmQgghGi7Qzw2AC7lFlJZVWDYYIYQQTZYk3Y1EpVLRWl/FPC2nQW1Zar/u9Vv3sO/QCU4mJPPIc2/w9sffUlRUYtprXJlafku3Trg6O5m0bSmmJoQQwpQc7W1wd7EH4Hy2VDEXQghRM0m6G1FYcFUV8+T0XLRa3Q3OvjZL7Net0+n4dslqANq2rton9effNnPXwy/wx97DJrmGoihs2FqVdJtyarmeYdswSbqFEEKYiH60+1ymJN1CCCFqJkl3I/LzcsbB3pryCi3nGrD+S1/B/GzyOfIvF5oouuv7fXccyWnncXSw539v/4MPXn+OQD9vsi9e4tmX3+flNz/jUl5Bg65x4nQS6RnZ2Nna0O+WLqYJ/Cp/FlOT6eVCCCFMI8iQdOdZNA4hhBBNlyTdjUilUhEWVDXanZha/ynmHu6uhAT7oygKhxthtFtRFL5ZsgqASeOG4OToQI+YKL7736vcOXEEarWK9Vt3c9dDL7Buyy4URanXdfSj3AN6d8XeztZk8ev9uW2YjHQLIYQwjQAfF1QqKCgs5XJRqaXDEUII0QRJ0t3IwlpVretOTs9Fq6v/FPPG3K/7wOF4TpxKxMbGmqkThhuO29nZ8sQDd/DFf16kTWgQeQWFzHvrc56d91+yLtTtSwWtVmfYKmzYoF4mjV9Pn3RnX7xEUbFp16ILIYS4OdlYW+Hj6QxAukwxF0IIUQNJuhuZn5cL9rbWlJVXcj6r/p1zYxZT+3px1Sj3rSMG1LhFWVS7ML764GUeuPc2rK2s2Ln3MHc99CI//7YZXS2/WDh45CQ5l/JxcXakV9eOJo1fz9XZCfcr8aelZ5nlGkIIIW4+Qb6uAA1aOiaEEKLlkqS7kanVpqliHtOxKuk+fTbF5BXEr3biVCL7406g0Wi4a9LIa55nbW3FfXfdytcfzaNjZBuKS0p5++Nvmf33N2tVuGzDtqp9XQf36461tfm2jw+5MtotxdSEEEKYir6YWnpmfr2XWAkhhGi5JOm2gLArSXfSuRx0uvp1zj7eHgT6eaPTKRw5kWDK8Izo13IPH9QLf1+vG57fOiSQT9/+J08/fDf2drbEHTvNtEfn8vXi36isrKzxMeXlFWzZsf/KdUxftfxqhgrmUkxNCCGEifh6OmOlUVNSVkFufrGlwxFCCNHESNJtAQE+rtjZWFFaVtmgfT27mHmKeXLqebbtPAjAvZNH1/pxGo2ayeNj+f7T17ileyfKKyr5dOEy7nvyVU6dSa52/u4DRyksKsHb092wVt1cQmSvbiGEECam0ajx96lavnQ8IVNGu4UQQhiRpNsC1GoVoaaYYq5Puo+ZJ+n+9qeqfbkH9O5K65DAOj/e39eL/8z/G3OffQAXZ0cSElOZ9eSrfPx/SygtKzect35r1dTy2IE9UavN+5bUF1NLSZOkWwghhOmEh3oDcOJMJut2nKS8oubZXUIIIW4+knRbSBv9FPO0+k8x1yfd8aeTKSktM1lsABlZF1m3pSoZnjZ1TL3bUalUjBrahx8/f53YAT3R6nR8t3QN02bP5eCRkxQVl7Bjz2HA/FPL4c/p5Wnns9Bq6189XgghhLhaRKgPg3q1Ra1WkXwul+Xrj5BXIDtlCCGEkKTbYgJ8XbG1saKkrILMiwX1asPf1wtfbw+0Wi1H48+YNL4flq1Fq9XSvUsUHdqFNbg9DzcXXp3zCG+9/ARenm6kpWcx++9v8reX/kNZWTmtAv1o1zbEBJFfn7+vF9ZWVpSXV9R5WzMhhBDietqH+TI+thOO9jZcKijh5/WHSUnPtXRYQgghLEySbgvRqNWEBnoAkJhav+RPpVL9uV/3UdPt152bV8Av67YDMG1K/Ue5a9L/lhh+/OxfTBg9CICjJ6q+LBg2qBcqlcqk16qJRqMmOMgXkCnmQgghTM/X05lJI6Lx83ahvELLmu3xHDiWJuu8hRDiJiZJtwXpq5gnnrtY7844plN7wLTF1Jas2EB5eQWREa3p3iXSZO3qOTk68PfHp/Pxm38nONAXF2dHxgzrZ/LrXEtIoL6YmlQwF0IIYXoO9jaMG9yBqLZVdUT2HU1l/Y5Tss5bCCFuUubbEFncUJCfGzbWGopLKsi8eBl/b5c6t6Ff133i1FnKyiuwtbFuUExFRSUs+20TUDXKbc7R566d27P4izeoqKjEpoFx10VIsOzVLYQQwrw0GjUDerTB28OR3/cnknQuh7z1xYwYEImbs72lwxNCCNGIZKTbgjQaNSH6KeZpF+vVRnCgLx7uLpRXVHLiVGKDY/p51WYKi0oIDQ5gQO+YBrd3IyqVqlETbrhq2zCZXi6EEMLMItv4MX5oJxzsravWea87TOr5S5YOSwghRCOSpNvCwq7aOqw+U8xVKtWfW4c1cIp5aVk5Py5fD8C9U0abffsuS2kVWDXSnSrTy4UQQjQCXy9nJo3ogq+XM+UVWlZvO8HB4+dknbcQQtwkWmZW1YwE+7lhbaWmqLic7JzCerWhX9cd18D9uldt2MGlvAL8fDwZPqhXg9pqyvTbhuVcyudyYbGFoxFCCHEzcLS34dYhHYlqW1XMc++RFDb8cYqKCq2FIxNCCGFuknRbmJWVhpCAhk0x11cwP3riDJWV9SvSUqnV8v3SNQDcNWkkVlYtd7m/o6M9Xp5uAKTKum4hhBCNpGqdd1sG9GiDWq0iMS2H5RuOkH9Z9vMWQoiWTJLuJiCsVcOmmLduFYCrixOlZeXEJyTXK4aN2/aQkXURd1dnxg3vX682mhP9aHeyrOsWQgjRyKLa+nHrkI442FmTm1/MsnWHScuQdd5CCNFSSdLdBAT7u2OlUXO5qIyLl4rq/Hi1Wk10B/1+3XWfYq7T6fh2yWoApkwYjp2dbZ3baG5Cgq6s606Xdd1CCCEan5+3C5NGROPj6WRY533ohKzzFkKIlkiS7ibA2kpDqwB3ABJT6zfFvCHF1P7Ye5jElHQcHeyZNHZIva7f3EgFcyGEEJbm6GDL+KGdaN/GF0WBPYdT2LjzFBWVss5bCCFaEkm6mwh9FfOz9Zxirk+6Dx9PoFJb+85aURS+XvQbABPHDsbZyaHO126O9NPLU9JkpFsIIYTlaDRqBvZoQ//uYahVKs6m5rB8/REKCkstHZoQQggTkaS7iWgV4I5Go6agsJScvLpX1G7bOhgnR3uKS0o5k5hW68cdPHKS46cSsbGx5o4Jw+t83eaq1ZXp5ecysur0JYUQQghhaiqVig7h/owb2hF7o3XeeZYOTQghhAlI0t1E2FhbEezvBsChE2mUV9StCrlGo6bzlXXddZli/s3iVQCMHd4fD3fXOl2zOfP19sDW1obKSi0ZmRcsHU6DFFwuorS0zNJhCCGEaCD/q9Z5l5VXsnrbcfYcTqnzZwIhhBBNiyTdTUhkWNXenWdTc1i06iCnkrLrNNU8pqM+6T5Zq/NPJiSz99BxNGo199w+qu4BN2NqtZpWgVWj3cnNeIp59oVcptz/Dx54+l9SfEcIIVoAJwdbbh3aiXatfVAUOHTiHD/8epBjCRlodTpLhyeEEKIeJOluQkICPRg1IBIXJzuKSyrYsjuBFRuOkp1zuVaP16/rjjuWgK4WHbN+lHvY4Fvw9/Wqf+DNVOiVYmrNea/uL79fQX5BIWeS0rhwUbabEUKIlsBKo2ZQr7YM79ceV2c7Sssq2LE/kSWrD9V7e1EhhBCWI0l3ExMS6MHU0TH0ig7BykpNVs5lfl5/hC27EyguKb/uY9u1DcHezpbLhUUkpqRf99zktAy27jwAwL2TR5ss/uZEv647pZkm3clpGazasMPw86mzqRaMRgghhCmpVCrCgj2ZMjqGft3CsLO1Jv9yKet3nGTFxqNkXiiwdIhCCCFqSZLuJkijURMTFcSdY7oSEeoNwKmkbBatOsjh+HS02ppHsa2srOgU2Ra48bru735ajaIoDOgdQ1hIoGmfQDPR3CuYf/b1MnS6P0c7Tp9NsWA0QgghzEGjVtMxwp+7xnWla4cgrDRqsi5eZsXGo6zfcZK8yyWWDlEIIcQNSNLdhDk62DKkdwQThnXC28OJ8gotu+KS+WlNHKnna55KXJv9ujOzc1i7eRcA06aMMX3gzYRhr+5mONJ9/ORZtv5xALVaxa0jBwCQkCgj3UII0VLZWFvRs3MId4ztSvswH1QqSEzLYcmqQ/y+/ywlpdefDSeEEMJyJOluBvy8XJg4vDODerbF3taavMslrN52gjXbTlT7hvvPdd2nr7nm68ef16LVaukW3Z4O7duYPf6mKjiwqnBdfkEhefm1WzffFCiKwidfLQVg1NC+DB90CwCnZXq5EEK0eE4OtgzqFc7kkV1oFeCOTlE4npDJD78e5MDxNCoqZRtMIYRoaiTpbiZUKhXt2/hyx9iuRLcPQK1SkXL+EktWH2J3XLJhO5HIiNbY2FhzKa+AlHPVp01fyitg5drtAEybMrZRn0NTY29ni5+PJ0CNv6umas/BYxw8chIbayvuv2cC4WGtAMjIukjB5SILRyeEEKIxeLg5MnpgFOMGd8DL3ZGKSi37jqTy428HOXk2y2j5kRBCCMuSpLuZsbWxondMayaP7kKwvxs6nUJcfDqLfqvaYsza2oqOV0ava9o6bMkvGykrKycyPJQeMVGNHX6TE9LMiqnpdDo+WVA1yj1p3FD8fDxxcXY0VJ8/k5RmyfCEEEI0skA/NyaNiGZo7wicHG0pLiln694zLF0bR8r5XKl0LoQQTYAk3c2Uu4sDowdG/bnFWGnVFmPLNxwhvE0oUH1dd1FRCct+3QTAtKljUKlUjR12k9MqSL9tWPMY6d64fS8Jiak4OtgzfeqfMxX0o92npJiaEELcdFQqFeGh3twxpiu9u4RiY60hN7+YNdvi+W3LcS7kFlo6RCGEuKlJ0t2MqVQqoy3GrK3UZOcUcqmw6mU9dOSU0Tfcy1dv4XJhMSHB/gzo3dVSYTcphmJqaU1/pLuiopLPv/4ZgLtvH4mri5Phvog2VUm3rOsWQoibl5VGTXRkIHeN61a1FE2tIj0rn2XrDrNp52kKCkstHaIQQtyUJOluAfRbjN1xZYsxb28f1Go1F3Pz2LTjKFqtjrLyChYtXw9U7cutVstLD81revkv67aTnnkBD3cX7rhthNF9EW1CAEiQpFsIYUIff/wxoaGh2NnZ0atXL/bu3XvNcxcuXIhKpTK62dnZGZ0zY8aMaueMHDnS3E/jpmNna03vmNbcMaYr4SFVW48mpFxg0aqD7D+aKlPOhRCikVlZOgBhOvotxjqE+7NlyzrOZ2SwZst+cgoqKSnMJOdSPr7eHoZq1+LPke7zGReoqKjE2rpp/pcoLillwQ8rAbjvrvHY29ka3R/RJhiA5NTzlJVXYGtj3egxCiFalsWLF/P000/z6aef0qtXL95//31GjBjBqVOn8PHxqfExLi4unDr159KmmpYxjRw5kq+++srws62tbbVzhGm4ONkxtE8EndsHsDsumfSsfPYfS6OgqIxBPduiVssyMyGEaAwy3NkC+Xo5E9u/avr4xYvZ5OQV8f3StQBMvW14k00sLcHLww0Hezu0Oh3pGdmWDuealqzYQO6lAgL9vLl1xIBq9/t4eeDq4oRWpyMx+ZwFIhRCtDT/+c9/eOCBB5g5cyZRUVF8+umnODg4sGDBgms+RqVS4efnZ7j5+vpWO8fW1tboHHd3d3M+DQF4ezgxdnAHBvZsi0oFp5OyWfd7vGwvJoQQjUSS7hYqpnPVft0F+RcpK86hsPAydnZ2lGqdSUnPtXB0TYdKpTJMMU9uouu68wsK+W7pGgAenD6xxi9NVCqVYV13QqJMMRdCNEx5eTkHDhwgNjbWcEytVhMbG8uuXbuu+bjCwkJCQkIIDg5m/PjxHD9+vNo5W7duxcfHh3bt2vHII4+Qk5NzzfbKysooKCgwuon6UalURLbxZUT/SDQaNSnnL7Fqy3HKyistHZoQQrR4knS3UJ0i26JRq8nMzmH7jh0AdOnchbIKhTXb49m48xQlpeUWjrJpMBRTa6Lrur9e/BtFxSVEtGlF7ICe1zzvzwrmknQLIRrm4sWLaLXaaiPVvr6+ZGbWvNtDu3btWLBgAStXruS7775Dp9PRp08fzp37c/bNyJEj+eabb9i0aRNvvvkm27ZtY9SoUWi1NY+4vvHGG7i6uhpuwcHBpnuSN6nQQA/GDu6AjbWGzIuXWbnxKIXFZZYOSwghWjRJulsoRwd7ItpWFdfKzM7Bwd6Ol/52F9HtA1Cp4EzKRRatOsSppOybvqBKqysj3U1x27DM7BzDNm+PzLz9ugXw/qxgLtuGCSEaX+/evZk2bRpdunRh4MCB/Pzzz3h7e/PZZ58Zzrnjjju49dZb6dSpExMmTOC3335j3759bN26tcY258yZQ35+vuGWlpbWSM+mZfP3dmF8bCcc7K3JzS9mxcaj5BWUWDosIYRosSTpbsG6dIww/HvimMF4uDnTO6Y1E4dH4+nmSFl5JVt2J7Bq64mbehuRkKCmu23Yl9+toLyikq6d29Ora8frntvuSgXzs0nn0Gp1jRGeEKKF8vLyQqPRkJWVZXQ8KysLPz+/WrVhbW1NTEwMZ86cueY5YWFheHl5XfMcW1tbXFxcjG7CNDzdHJkQ2xlXZzsKi8pYsfEI2TmXLR2WEEK0SJJ0t2AxndoDYGNtZbTFlLeHExNHdKZXdAgatYpzmXksWX2IwyfT0eluvlHvq6eXN6VR/6SUdNZs+gOAR2feXmMV4KsFB/pha2tDSWkZ5zKyrnuuEEJcj42NDd26dWPTpk2GYzqdjk2bNtG7d+9ataHVajl69Cj+/v7XPOfcuXPk5ORc9xxhPi5OdkyI7YSXuyOlZZX8uvkY5zLzLB2WEEK0OJJ0t2C9e3TijtuG88+/3Yenh6vRfRp11d7ek0fF4O/jQqVWx65DySzfcIScS0UWitgyggJ8UatVFBaVcCmv6RTp+fTrn9HpFAb17UaH9m1ueL5Go6ZtaBAAp8/Ium4hRMM8/fTTfPHFF3z99dfEx8fzyCOPUFRUxMyZMwGYNm0ac+bMMZw/f/581q9fT2JiIgcPHuSee+4hJSWF+++/H6gqsvbcc8+xe/dukpOT2bRpE+PHj6dt27aMGDGixhiE+dnb2XDr0I4E+rpSUalj9bYTnEm9aOmwhBCiRZGkuwWz0mh48sE7GTH42qMSbi723DqkIwN6tMHGWsOF3EKWrTvM3iMpVN4kU5Rtbazx9/ECmk4F86PxZ9i+6yBqtYqHpk2s9eMirkwxl3XdQoiGmjp1Ku+88w5z586lS5cuxMXFsXbtWkNxtdTUVDIy/vybeenSJR544AEiIyMZPXo0BQUF7Ny5k6ioKAA0Gg1Hjhzh1ltvJSIiglmzZtGtWzd+//132avbwmysrRg9MIqwYE90OoWNf5ziWELT6A+FEKIlkA2bBSqViqi2foQEuLPjQCJJ53I5ePwciak5DOzZBn8f1xs30syFBPuTnnmBlHMZdO3c3qKxKIrCJwuWAjBmWD9CWwXU+rHhbaoq+8q2YUIIU3jsscd47LHHarzvr8XP3nvvPd57771rtmVvb8+6detMGZ4wIY1GTWyfduw4kMiJM5ns2J9ISWkF3TsG33B5kxBCiOuTkW5h4Ohgy4j+kQzv1x4HO2vyLpewctMxtu872+L38TSs606zfAXz3fuPEnfsFDbWVtx/94Q6PfbPke7UJrU+XQghRNOnVqvo3z2Mbh2rvsA9cCyN3/cn3pT1XoQQwpQk6RbVhAV7MnVMV9q3qZpCeOJMJktWHyL5XI6FIzOfVoH6bcMsO51Op9Pxv4VVo9y33xqLj7dHnR7fJjQItVrFpfzLXMjJM0OEQgghWjKVSkWPTq3o1z0MqPoMsHHnKdkVQwghGkCSblEjWxsrBvVsy7ghHXBxsqOopJy1v59k/Y6TFJeUWzo8k/uzgrllR7o3bN1DQmIaTo72TJs6ps6Pt7O1MWyBJlPMhRBC1FfHcH9i+7ZDrVaRmJbD6m0nKK9o2bPehBDCXCTpFtcV6OvGlFFd6BIZiEoFiWk5LFp1kLj49Bb1rbc+6c7IukhpmWW+VKioqOTzb5cDcM/k0bg6O9WrnYg2rQAppiaEEKJh2rbyYvTAKKyt1KRn5fPLpmOUlLa8L96FEMLcJOkWN2RlpeGWLqFMGh6Nt4cj5RVadscls3j1IRLTclrE2mF3V2ecnRxQFIVz5y2zx/WKNVs5n3kBT3dXpowfVu92rl7XLYQQQjREkJ8b44Z0xM7WiouXili+4SgFhaWWDksIIZoVSbpFrXl5OHHbsGgG9WqLg501BYWlrN9xkl82H+NCbqGlw2sQlUplmJZtiSnmxSWlfPXjrwDcd/d47O3qv32OfqQ7QZJuIYQQJuDj6cyE2M44OdpSUFjKio1HyLlUZOmwhBCi2ZCkW9SJWq2ifZgvd47tRtcOQWg0ajKyC1i27jBbdidQVFxm6RDr7c8K5o1fTG3R8vVcyisgKMCHW0f0b1Bb4VeS7vTMCxQWFZsiPCGEEDc5Nxd7bovthIerA8UlFazcdJSM7HxLhyWEEM2CJN2iXqytNfTsHMIdY7rSNsQLgFNJ2fz420H2H0ulolJr4QjrLiTIMhXML+UV8P3SNQA8NG0iVlZWDWrP1dkJPx9PQKaYCyGEMB1HB1vGx3bCz8uZ8gotv209QVIL3tlECCFMRZJu0SDOjrbE9mnHbcM64+vlTKVWx/6jaSxadZDTSdnNar13KwtNL/968SqKS0pp1zaEIf17mKRNwxRzqWAuhBDChGxtrBgzuAMhAe5otTrW/X6SDX+clHXeQghxHZJ0C5Pw9XJmQmwnYvtE4ORgS1FxOZt3J7B8wxEyLxRYOrxauXp6eWN9WZCRdZGff9sMwKMzJ6NWm+a/ZHiYvoK5JN1CCCFMy9pKw/D+7ekYXtVvnk3NYfGqg+yJS5ZtxYQQogYNm8cqxFVUKhVtQ7wJDfTgyKnzHDpxjuycQlZsPEqbVp70ig7FxcnO0mFeU5C/NxqNhpLSMi5cvISPt4fZr/nldyuoqKykW3QkPWKiTNbun9uGtZyku6i4hCPHEzhw5CTnzmfx8IzbCb3yRYkQQojGpVGr6dc9jPZtfNh5MJnz2fkcik/nZGI2PTq3on2YL2q1ytJhCiFEkyBJtzA5KysNXTsE0z7Ml71HUzl5NouzqTkkn8ulc7sAYjoEYWPd9N56VlZWBPp5k5qeScq5TLMn3WeTz7Fm004AHp15OyqV6T6c6LcNS0o9T3l5BTY21iZru7GUlJZdSbLjOXTkFPGnk9Dq/twbXlHgzbmPWzBCIYQQXu5OjBvSgeT0XHYdSqagsJTt+85yPCGD3jGtCfJzs3SIQghhcU0v8xEthoO9DYN6tqVjuD+7DiWRntX0vwUPCfa7knRnmHTkuSaffb0MRVEY3K87Ue3CTNq2r7cHzk6OXC4sIik1nXZtQ03avjmUlpVzLP4MB46c5ODhk5w4nUjlXwryBfp506F9G9Zv3c0fe+K4kHMJb093C0UshBACqma6tQ7ypJW/O8cSMjhwLI2cvGJ+23KckEB3endpjZuLvaXDFEIIi5GkW5idl7sjYwd3ICU9l11xyeRfbrrfgocE+fM7cWbfNuzw8QR+3x2HRq3moekTTd6+SqUiok0rDhyO59TZ1CaZdJeXV3D8VCIHj8Rz4PBJjsWfpaLSeC2gn48nXTu3p2vn9nSLjjRUZc/MzuHIiQRWrd/BjDvHWSJ8IYQQf6HRqIluH0hEax8OHE3j+JkMUtIvkXY+jw4RfnTv2ApbG/noKYS4+Vj0L9/27dt5++23OXDgABkZGSxfvpwJEyZc9zFbt27l6aef5vjx4wQHB/Piiy8yY8aMRolX1J9KpSI0yJNgf3eOJ2Sy/1iq4Vvw0EAP+nYLw9nR1tJhGoqppZqxgrmiKPzvq58AGDu8PyFB5lmXrE+6E5rIuu6KikpOnE4yJNlH489QXl5hdI6XpxvdOrena3Qk3Tq3J8DPu8Zp9+NHDeTIiQRWrt3GtKljTFaATgghRMPZ21rTr3sYHcL92BWXTOr5Sxw9lcHppAt07xRMVFs/NPJ3WwhxE7Fo0l1UVER0dDT33XcfEyfeeLQvKSmJMWPG8PDDD/P999+zadMm7r//fvz9/RkxYkQjRCwaSqNR07l9ABGtvdl/LI3jCRkkp+eSnpVHr+hQOoT7mXRtc121urJXd4oZ9+reue8Ih48nYGNjzX13jzfbdZpKMbW4Y6dZ+OMvHD6eQGlZudF9Hu4udOsceWUkuz1BAb61ev2H9O/B+5/9QGZ2DnsOHqd3907mCl8IIUQ9ubs6MHpgFGkZl9h5KJlL+cX8cSCJ4wmZ9O4SSqsAd4v2+UII0VgsmnSPGjWKUaNG1fr8Tz/9lNatW/Puu+8CEBkZyY4dO3jvvfck6W5m7Gyt6dctjA5t/di29wyZFy+z40AiZ1IvMrBnG9xdHCwSl37UOetCLiWlZdjbmXb0XavV8b+vlgIw5dZYfLzMtx5ZX0ztTFIaOp3OYqPB73z8LWeTzwHg5uJEzJWp4t06tyck2L9eH7jsbG0YNbQPS1ZuZOWarZJ0CyFEExbs785kXzfiz2ay72gqeQUlrNkeT5CfG31iQvFwc7R0iBahKAo/r9pC+/BQOpi4tosQomlpVnN7du3aRWxsrNGxESNGsGvXrms+pqysjIKCAqObaDrcXR0YH9uJft3DsLZSk3mhgJ/WxHHweJpRperG4urihLurM2D6KeaKovDJVz9xNvkczk4O3DtljEnb/6tWQX7Y2FhTXFJKeka2Wa91LVkXcjibfA61WsWC/85l1Y//5fUXZjNp7BBCWwU0aITj1pEDAdixO46LuXkmilgIIYQ5qNUqOoT7c+fYbkS3D0StVnEuM4+f1saxfd8ZSkrLb9xIC3PkeALvfPwtb7z/laVDEUKYWbNKujMzM/H19TU65uvrS0FBASUlJTU+5o033sDV1dVwCw4OboxQRR2oVCo6hvszZXRXgv3d0ekU9h5J5ed1R7iQW9jo8Zhrivl3P63mh2VrAfjbw3fj4mzeb/atNBrahAYBcMpCU8x37jsCQIf2bYiMaG3S0fY2oUF0imqLVqfjt/U7TNZuQ+l0On5cvo5d+49aOhQhhGhybG2s6B0TytTRMbQO8kRR4MSZLH787SCHTpxDq238L9wt5WxKOgDpGdkoimLhaIQQ5tSsku76mDNnDvn5+YZbWlqapUMS1+DsaMvogZEMuSUcOxsrcvKK+Hn9YXbHJVfbOsqc9MXUTFnBfOWabXxyZVr5Ew/cwaihfUzW9vX8ua47pVGu91e7riTdfbp3Nkv7E0YNAuCXtdvQWWBmRE02/76PDz5fxJzXPiI3T2bWCCFETVyd7RnRvz23Du2Il7sj5RVa9hxOYdGqg5xJuXBTJKFp6VUz6krLyiksqnnwSAjRMjSrpNvPz4+srCyjY1lZWbi4uGBvX/P+j7a2tri4uBjdRNOlUqmIaO3D1DExtG3lhaJAXHw6S9bEcT47v1Fi0K/rNtVI95Yd+3nro68BmDZ1DHdObLz6A/p13QmJjf9lU3l5BfsOnQCgdw/zJN1D+vfA2cmBjKyL7D103CzXqAtFUfh68SoAysrKDTMbhBBC1CzAx5VJI6IZ1KstDvbWXC4qY+PO0yzfcISMRur3LeXqZWwXci5ZMBIhhLk1q6S7d+/ebNq0yejYhg0b6N27t4UiEuZib2dDbN92jOzfHgd7GwoKS/ll0zG27ztDWXnljRtoAP30clOs6d576Dgvv/kZOp3C+JEDeXj6pAa3WRcRYZYb6Y47dprSsnK8PNwMI+6mZmdrw8ghVbMGVq7ZZpZr1MXOfUc4k5Rm2Apn2a+buCSj3UIIcV0qlYr2Yb7cOaYb3TsGY2WlJjunkJWbjrH293jyCootHaJZpKb/+Tkj+2KuBSMRQpibRZPuwsJC4uLiiIuLA6q2BIuLiyM1tWr96Zw5c5g2bZrh/IcffpjExESef/55Tp48ySeffMKSJUv429/+ZonwRSMIDfJk6ugYotpWreU/cSaLJasPkZxuvs7JML38XGaDpiwfP5XIP+Z/SEVlJYP7due5x6Y1+tYobVsHoVaryL1U0OjFxv7YexiA3j06mfV5jx9VVVDtdwsXVFMUhYWLfgXgjokjaNc2hNKycn5cvs5iMQkhRHNyND6BQ3EHmDKqC5FtfFGpIPlcLotXH+L3/WdbVLG1iopKMjIvGn6+cFFGuoVoySyadO/fv5+YmBhiYmIAePrpp4mJiWHu3LkAZGRkGBJwgNatW7Nq1So2bNhAdHQ07777Ll9++aVsF9bC2dpYMaBHW24d2hEXJzuKSspZuz2ejX+cMksH7O/rhbWVFeXlFWRdqF9yn5x6nmfmvkdJaRk9YqKY9/yDaDSN/9/Nzs6WVoFVXyIkNHIxtV37r6znNtPUcj1DQTWtllUbLFdQ7dDRUxyLP4uNtRV33jaC++66FYBlv24mv6DxCwIKIURzcu58Ns++/D4LfviF/YeOMbBnWyaPiiEkwB1FgeMJmfzw60EOHk+johHrvJjL+awLRru0XMjJs1wwQgizs2jSPWjQIBRFqXZbuHAhAAsXLmTr1q3VHnPo0CHKyso4e/YsM2bMaPS4hWUE+LgyZVQXukQGolLBmdSLLF51iNPJpq36aaXREBxYNbJen3Xdmdk5PPnCO+QXFBLVLox/v/Q4NjbWJouvrsLbVFXsb8wK5mnpmaSlZ2FlpaFHlw5mv974K9uH/bJ2u8UKqn2z+DcAxg7vj6eHK/1viSE8rBXFJaUsktFuIYS4Jq1Wx/x3v6CktAyAYyfPAuDh6sCogVGMG9IBL3dHKiq17D2SyqLfDnIyMQudrvkWW0s9Z1yjSKaXC9GyNas13UJYWWm4pUsoE4dH4+nmSGl5JZt3JbB6WzyXi8pMdh3DtmF1rGB+Ka+AJ//5DtkXLxEaHMC7rzyFg72dyeKqD30xtcZc163fLiu6QwSOjjUXOTSlof174ORoz/nMC4bibY3pZEIyew4eR6NWc/fto4CqNYr60e4lKzeSf1lGu4UQoibfLV3N0RNnDD/rk269QF83Jo2IZkjvcJwcbCkqKWfrnjMsW3eYtIy8Ro7WNFKvfKmvVlctv5KRbiFaNkm6RbPk7eHExBGd6dm5FWq1irSMSyxZfZBjCRkmGfU2VDBPq30xtaKiEp6e+x6p6Zn4+Xjy3389g5urc4Njaag/tw1rvJHunVfWc5t7armenZ2tRQuqfXOlYvmwwbcQ4OdtOD6gdwxtQoMoLill8fINjR6XEEI0dafPpvLldysAmD51LACnEpKpqDAumqpSqYgI9eGOsV25pUsINtYacvKKWLX1OKu2HCfnUlFjh94gaelVI93trnwxfkFGuoVo0STpFs2WRq2ma4dgJo/qgp+XMxWVOnbsT2TlxqOknM9t0LQzfTG11PTajXSXlVfw91c/4GRCMu6uzrz/r2fw8fao9/VNSV/BPD0jm6JG2Ae0pLSMg0dOAY2XdMOfBdW27z5ETm7jbTOTnHqerTsPADBt8mij+9Rq9VWj3Ru4XNgyK/AKIUR9lJVX8Mrbn1NZqWVgn648NH0iri5OlFdUcjqx5i+KrTRqukQGcde4bnRq51/1xXtmHj+tjWPL7gQKi003682c9JXLu0VHAlJITYiWTpJu0ey5uzgwPrYT/bqFYW2lJvPiZdZsi+eHX/ez72gql4tK69zmn9PLbzzSXanVMvffn3Lg8Ekc7O34z6tPG0bKmwI3V2d8vNwBSEgy/37d++PiqaisxN/Xy/DlRWNo2zqYjpFtqgqqbWy8gmrf/rQaRVEY2KcrrUMCq90/qG83wkICKSouYcnK9Y0WlxBCNHWffb2MxJR0PNxd+Pvj01GpVHRo3waA43+ZYv5XdrbW9O0axtTRMYQFewJwKimbRb8dZO+RFMorzLu9aEPpR7q7Xkm68woKKSuvsGRIQggzkqRbtAgqlYqOEf5MGd2VThH+2NpYUVhczoFjaXz/ywFWbT1OYtpFtNraFdkKuZJ0X8zNo7Do2qOTiqLw7/8uZPuug9hYW/H2vCdpHx5qiqdkUo25rnvXvitVy3t2bvQt0iaMGgTAL2u2NUpBtYysi6zbvAuAaVPG1HiOWq1m5p3jAFi8YsN1309CCHGzOHjkJIuWV30ROefJmbi7uQDQsX0YUH1d97W4OtszvF97bhvWGT8vZyq1Og4eP8ePvx7keEKGUYXwpqKouMSwxWXH9m0MxVYv5shotxAtlSTdokVxdrSlb7cw7p3Qg6G9Iwj0dQUgLSOP9TtO8d3K/ew6lExewfUTHydHB7w83ICq/bqv5eMFP7Fqww7UahXz//EIXTu3N9lzMaXGWtetKAo7911Zz9298aaW6+kLqqVnXmB/XLzZr/f9sjVodTp6xEQR1S7smucN7teD0OAALhcW89MvG80elxBCNGWFRcW8+u6XKIrC+JED6deri+G+P0e6E+vUpq+XM+NjOzGiX3tcne0oKavg9/2J/LQmrsmt99aPcru7ueDs5IC3Z9VsNCmmJkTLJUm3aJGsNGrCQ70ZN6Qjd47tSkxUEA521pSUVXD4ZDqLVh1i5cajnE7KpvIa+32GBFeNdqdeI+n+dskqvl+6Bqj6ln5gn67meTImEB7WOEl3Yko6WRdysbGxtsgXEHZ2towY0huAFWu2mvVauZfy+XXd78CfxX+uRaNRM/OuqtHuH39e3yhr64UQoqn6z/++JzM7h0A/b5548A6j+6IiWqNSqTifeYHcS3Wrz6FSqWgd7MmU0TH06xaGna0VeQUl/Lr5GBebUOKtX8+tn1WnT7pl2zAhWi5JukWL5+psT6/oEO4e350R/dvTKsAdlQoyLhSweXcC36zYx+/7z1brkFsF6iuYVy+mtnLNNj75aikAj82awtjh/c3/RBqgXduq6eVJqenVKsKakn5qeffoSOzsbM12nevRTzHfvutQnT+w1cWiFespL6+gY/s2tfqCYWj/nrQK8uNyYRFLf9tktriEEKIp2/rHftZs2olareKlZx+otq2mk6MDrVsFAHD8VN1Gu/U0ajUdI/y5c2w3fDydKC2v5LfNx5rMiHfalaQ7ONAXwFB3RYqpCdFySdItbhoatZrWQZ6MHhjF3bd2p0enVjg72lJeoeV4QiZL18axbN1hTpzJpLyi0jDSnXLOOOnesmM/b330NQD3Thlt2Je5KfPz8cTZyYHKSi1JqefNdp0/9lYl3b0bsWr5X7VtHUzH9lUF1X7bYJ6CapcLi1n262YApk0dW6u16xrNn2u7f/x5HcUldS/wJ4QQzVlObj7//qCq/7xn8miiO4TXeF6HOq7rvhZbGyvGDOpgSLx/bSKJd+q5qunlrQKvjHR7yfRyIVo6SbrFTcnJwZZuHYO5a1w3xgzqQFiwJ2q1igu5hWzfd5Zvlu8jv6hqy7Gr13TvO3SCl9/8DJ1O4daRA3hkxu2Wegp1olKprppibp5iapcLizl6IgGA3t07meUataXfPsxcBdWW/bqJ4pJS2oQG0bdn7b9giB3Yi+BAX/ILCln2q4x2CyFuHoqi8Pr7C8gvKCQ8rBX33z3hmud2vLKu+1h8w5Ju+DPx9va4knhvOUZOnmUT71TDSHdV0q0f6Zbp5UK0XJJ0i5uaSqUi2N+N4f3ac+/4HvTuEoqbiz2VWh0FxVVJd2paBqcSMzl+KpF/vPohFZWVDOrbjecfm97o1bkbwtzF1PYeOo5WpyMk2J9Afx+zXKO2hg7oiaPDlYJqh01bUK2ktIzFK6oq7k6bOga1uvZ/Rq00GsP67x+WraWktHnsJytuXh9//DGhoaHY2dnRq1cv9u7de81zFy5ciEqlMrrZ2RlPHVYUhblz5+Lv74+9vT2xsbEkJCSY+2mIJmDlmm3s3HcEaysrXn7uAaytra55rr6YWvzpJCq1NdddqQtbGyvGDr6SeJddGfG2UOKtKIqhVkyrK9PL/yykJtPLhWipJOkW4gp7O2uiIwOZOjqG8bGd6NIxDI1Gg1an45ulm3n8H29TXFJK9y5RvPL8Q2g0zeu/j37bsIRE8yTdhq3CLDi1XM/ezpaRQ6sKqq1cs82kbf+ydht5BYUE+vswpH+POj9+xJDeBPr7kFdQyM+/bTZpbEKY0uLFi3n66ad5+eWXOXjwINHR0YwYMYLs7OxrPsbFxYWMjAzDLSXFeGbNW2+9xQcffMCnn37Knj17cHR0ZMSIEZSWynKLliztfBYffLEIgEdm3k6b0KDrnt+6VQCODvaUlJaRlJJukhhqSrxzLZB4514qoLikFLVaZfiC2pB0y5puIVqs5pU1CNEIVCoV/t4uxPaOILRVVTG1rds2UVJaipenN7eOHYNOsXCQ9RAeFgxUjXSbesq1TqdjZxNKugHGj6yaYr5t50GTFVSrqKjk+6VrAbjn9lFYaTR1bsNKo2HGHVWj3d8vW0upjHaLJuo///kPDzzwADNnziQqKopPP/0UBwcHFixYcM3HqFQq/Pz8DDdfX1/DfYqi8P777/Piiy8yfvx4OnfuzDfffMP58+dZsWJFIzwjYQmVWi3z3/mCktIyunZuz9QJw274GLVaTVS71kDD13Vf7a+J9y+bjzd64q2fWu7v42XYn1s/vfxibr5ZlkQJISxPkm4hrqN1cFUFVZ1Oh5enB0OHjuBs6iV+/O0gxxMy0DWj7Ds02B8bayuKS0pJz7xg0rZPnUnhUl4BDvZ2RHeIMGnb9RUe1ooO7cLQarWsMlFBtTWbd3Ih5xJeHm6Mju1b73ZGDulNgJ83l/IKWG7mrc2EqI/y8nIOHDhAbGys4ZharSY2NpZdu3Zd83GFhYWEhIQQHBzM+PHjOX78uOG+pKQkMjMzjdp0dXWlV69e121TNG/f/bSGY/FncXSw58WnZ9V6SU599+u+kT8Tb0dKyyoaPfE2VC6/sl0YgIeHK2q1Cq1Wy6W8y40WixCi8UjSLcR16KfA+Xp78OV7/2Ty6G54uDpQVl7J7/sTWbbuMBkXCiwcZe1YWVkZnk+Cidd160e5e8REXXedXmPTF1RbuXZ7g0cPtFod3/20GoC7Jo00jFDUh5WVFdOnjgHg+5/WUFpW3qDYhDC1ixcvotVqjUaqAXx9fcnMzKzxMe3atWPBggWsXLmS7777Dp1OR58+fTh37hyA4XF1abOsrIyCggKjm2g+Tp1J4cvvVgDw9CN34+/rVevHGoqpmXCkW68q8e5onHjnF5v8OjVJ+ct6bqiaAeXh7gpIMTUhWipJuoW4joljh/DozNv539tz8PX2JNDXjdtHdqFvt9bYWGvIySti5cajbNx5isLipj9NONxMxdQM67l7Rpu03YaKHdirqqBaRjYHDp9sUFtb/thPWnoWLs6OhmS+IUYN7Yufjyc5l/JZKaPdogXo3bs306ZNo0uXLgwcOJCff/4Zb29vPvvss3q3+cYbb+Dq6mq4BQcHmzBiYU5l5RW88vbnaLVaBvXtxqihfer0+A7tqrYNS0nLoOCy6Uei9Ym3l3tV4v3rpmONknjrR7pbBfkbHZdiakK0bJJ0C3EdLs6O3DtljNG382q1ik4RAdw5thuRbaq+qT6TcpFFqw5y6MQ5tNqmux5LX0zNlNuGXcor4MTpJMDyW4X9lb2dLSOGXCmotnZrvdtRFIVvFv8GwJTxw3Cwt7vBI27M2tqKaVdGu7/7aQ1l5RUNblMIU/Hy8kKj0ZCVlWV0PCsrCz8/v2s8ypi1tTUxMTGcOXMGwPC4urQ5Z84c8vPzDbe0tLS6PhVhIZ8uXEpS6nk83F34++N13+3DzdWZoICqQmPHT5l2irmefqq5l7sjJY2UeKemV73/gwONZ3zok+5sKaYmRIskSbcQ9WRvZ83Anm2ZNCIaXy9nKit17DmcwuLVh0hJb5rTw/TbhiUkmu6D6+4Dx1AUhfCwVoYPDU3JhFFXFVTLq9/U1F37jpCQmIaDvR233zrUZLGNie2Hr7cHF3Pz+GWtaausC9EQNjY2dOvWjU2b/txPXqfTsWnTJnr37l2rNrRaLUePHsXfv2pEr3Xr1vj5+Rm1WVBQwJ49e67Zpq2tLS4uLkY30fQdOBzPouVVWyv+86n7cHN1rlc7HQ3ruk0/xVzPztbaOPHebL7Eu1KrJT2jqvp/q0DjL5r0xdRkpFuIlkmSbiEayNvDiQmxnRhySzgOdtYUFJayZns8q7edIK+gxNLhGWkTGoRKpeJibp7JKnrrp5b37dk0qpb/VXhYK6LahVFZqWV1PQqqKYrCwiuj3LeNGYyrs5PJYrOxsebeKVWj3d8uWU25jHaLJuTpp5/miy++4OuvvyY+Pp5HHnmEoqIiZs6cCcC0adOYM2eO4fz58+ezfv16EhMTOXjwIPfccw8pKSncf//9QFVl86eeeorXXnuNX375haNHjzJt2jQCAgKYMGGCJZ6iMIPComJeffdLoKquRt8GLDvqGNkWMM+67qvpE29PN0dKSqsS70tmSLwzs3KorNRiY2NtSLL1vL1k2zAhWjJJuoUwAZVKRURrH+4Y25Xo9oGo1SpSz19iyZpD7I5Lpryi0tIhAuBgb2eY0nbKBOu6K7Vadh84BkDvJrJVWE0mGAqqbatzQbW4Y6c5euIMNtZW3HHbcJPHNm54f7w93bmQc4nf1v9u8vaFqK+pU6fyzjvvMHfuXLp06UJcXBxr1641FEJLTU0lIyPDcP6lS5d44IEHiIyMZPTo0RQUFLBz506ioqIM5zz//PM8/vjjPPjgg/To0YPCwkLWrl2LnV3Dl2yIpuHd/31P1oVcAv19eOKBOxrUVsf2Veu6T5xKNPtWWna21owb8mfi/YsZEu/Uc1X/X4IDfKtVcdcn4TK9XIiWSZJuIUzIxtqK3jGhTBnVhWB/N3Q6hbj4dBatOsTp5GwUxfJbjLW7sq47IbHhSffx+LNcLizCxdmRDu3aNLg9c4kd2AsHezvOnc/m4JG6FVT7+soo95hh/fHycDN5bFWj3aMB+GbJKhntFk3KY489RkpKCmVlZezZs4devXoZ7tu6dSsLFy40/Pzee+8Zzs3MzGTVqlXExMQYtadSqZg/fz6ZmZmUlpayceNGIiKaxjaDouG27NjP2k07UatVvPzcAw2uf9EmNAhbWxsuFxYb1kKbU42Jd4HpEm/9c2gVVL2GgRRSE6Jlk6RbCDNwc3Fg9MAoRg6IxMXJjuKScjbvSmDlxqNczC20aGzhYVXVf01RTG3n/qqp5b26dUSjabp/TuztbBmpL6i2pvZrp0+dSWbPgWNo1Gruvn2kucLj1pED8fJwI+tCLqs3/mG26wghhLlczM3jzQ+/BuDeyWPodGVqeENYWVkRGR4KmHdd99X+mnj/usl0ibehcnngdZLui5eaxBf0QgjTarqfkoVo5lQqFaGBHkwZHUPPzq2w0qjJvHiZpesOs3HnKbIuXrZIx/pnBfOGj3Qb1nP3aFpbhdVk/KhBAGzdeaDWBdW+XrwKgGGDehHo72Ou0LC1seaeyaOuXPM3KprIcgQhhKgNRVF4/b0F5BcUEtGmFbPuHm+ytjuYcb/ua7GztWbskA54ujlQfCXxzjNB4n2tyuXw55ruktIyioqbVj0YIUTDSdIthJlZadR07RDMHWO70jakauuxMykXWb7hCD+vP8zJxCwqK7WNFo++gvm589kN6tizL14iITENlUpFr24dTRWe2US0aUVkROuqgmq1GE1OTstg6x8HAAzFzsxp/KhBeLi7kJmdw5pNMtothGg+VqzZyq79R7GxtmLecw9ibW1lsrb167oba6Rbz97WmrFDOhoS719MkHjr13TXNL3c3s4WZycHQIqpCdESSdItRCNxcrAltk87Jo2Ipl1rHzRqFRdyi9i65wzfrdzP7rhkLheVmj0OdzcXvD3dURSFM0nn6t2OfpS7Q7uwem8H09gmjB4EwMo1W284y+C7n1ajKAoDenclLCTQ7LHZ2dpwz+1Va7u/XryKykoZ7RZCNH1p57P44PNFADw883Zam/jvpX6k+2zyuUYfAdYn3h6uVxLvzfVPvEtKywxF0mqaXg5/jnZLMTUhWh5JuoVoZN4eTgy+JZx7JvSgV3QITg62lJZXEhefzg+/HmDt9njOZeaZdep5+JXR7oas6955JeluylXL/yp2QM9aFVTLyLrI2s27AJg21fyj3Hq3jR6Eu5sL5zMvGK4vhBBNVaVWy/y3v6C0rJxu0e2ZOn6Yya/h7emOr7cHOp3CyYRkk7d/I/a21ozTJ94lVYl3YloOpWV1K3p57nzV1HJXFydcXWreelKKqQnRcknSLYSF2NtaExMVxF3jujGif3sCfV1RFEhOz+W3LcdZvPoQx05nmGW7sQhD0l2/dd3l5RXsjzsBNN39uWviYG/HiMFVBdVWrN56zfN+WLYWrVZL9y5RdGgX1kjRgZ2dLXdPqirYtnDRb1RqG2/ZgRBC1NU3i1dx7ORZHB3sefHp+6ttg2UqHSMbf1331eztjBPv9TtOsvDnvSxZfYgd+xM5m3qRktLy67ZxvfXcevqkW0a6hWh5JOkWwsLUahWtgzwZN6QjU0fH0DHcH2srNXkFJew4kMi3K/bx+/6zJt0vtN2VpLu+24bFHT9NcUkpnu6uhIe1MllcjWH8lT27t+48wKUaCqrlXsrnl3XbAZjeiKPcehPHDsHNxYn0jGzWb9nd6NcXQogb0Wp1fPLVT3zx7XIAnnn0Hvx8PM12Pf0U88Ze1301eztrxg3tSMcIf9xd7AHIzS/mWEIGG/44xdfL97F41UG27zvLmZQLFJcYJ+Fp565duVxPv1e3jHQL0fKYrtKFEKLB3F0d6Nc9jJ7RrTiddIFjCRnkFZRwPCGT4wmZBPq60jHCn5AAD9RqVb2vo0+UE5PTqaysxMqqbn8K9Ou5b+neyWwjG+bSrm0IkRGtiT+dxOqNf3D37aOM7l+8cgPl5RV0aBdGt+jIRo/P3s6WuyaN5JOvlrJw0a8MH3wLVhpNo8chhBA1KSwq5uW3Pmfn3sNA1RIc/ZaM5tLRUME8EUVRUKnq3/81hL2tNf26Vc1+Kikt53x2Aeez88nILiA3v5hLBSVcKijhxJmqBNvV2Y4AH1f8fVw4m5IOQPB1ku6rtw0TQrQsknQL0QTZWFvRMcKfDuF+pGflcywhg5T0XNKz8knPysfJwZYO4X60D/PF3s66zu0H+Hnj5GhPYVEJSann6zxarV/P3bdn098qrCYTRg0k/nQSK9du465JIw0f4C4XFrPs180ATL9jrMU+2E0aN5Tvl60lLT2LTdv2MsLMH2iFuBkpisLh4wl06Rhh6VCajdRzmTw//wNS0jKwsbHmn0/NNCzZMaeINiFYWWm4lFdARtZFAvy8zX7NG7G3s6FNKy/atKralaSkrILMK0n4+ewCcvKKyL9cSv7lUuLPZhF3PBGAy8UKpxKz8fdxwcXJzqhNHymkJkSL1byGqIS4yahUKoL83BjZP5K7xnUjJjIQOxsrCovL2HM4he9W7mPz7gQuXiqqc7v6RLuu67rPnc8m9VwmGo2GHjFRdXpsUxE7sBcO9nakpWdx6Ogpw/Flv22mqLiEsNBAi36h4GBvxx23jQBgwY+/oNXqLBaLEC2RVqvj8Tlv8chzb7Dv0AlLh9Ms7Np/lFlPzSclLQMfL3c+e+efjZJwA9jaWBPRJgSw3LruG7G3taZ1sCd9u4UxeVQXZk7qxcgBkUS3D8DL3ZGCgnwACkthy54Efvj1AN+t3M/mXac5n111n756+UWZXi5EiyNJtxDNhLOjHb26hHLPhB4M7hWOt4cjWp3C6aRslq6NY8vuBIqKy2rdXn2Tbv3U8ugO4Tg5OtTpsU2Fg70dwwffAvxZUK20tIzFy9cBMG3KGItPm588bijOTo6knstk0+97LRqLEC2NRqMmLCQIgP9+/qMULbwORVH4fukann35PQqLSugcFc5XH7xM+/DQRo1Dv1/3sfimmXT/la2NFaGBHvSOaU1s7zaUl1et8e7boz2+ns6oVSoKi8s4nXyBXzYdY9/RVDzd3QC4lH+Z8vK6VUcXQjRtknQL0cxYadS0C/Nh4vBobhvWmTatqorXnErK5sffDrL/WCoVlTf+AFnfCuY79ze/rcJqMmHUIAC2/lFVUO2XddvJKygk0M+boQN6WjY4wNHRnjsnDgfgqx9+RaeT0W4hTGnW3eNxdnLkbPI5fr1SPFEYKy0rZ/47X/DR/y1Bp1O4deQAPnzjOTzcXRs9lg7tLVvBvCFS06vWePv5eDKgRzi3De/MzNt7MWZQByJa+wBw4FgaOw6mYG1dtfLzYm6epcIVQpiBJN1CNFMqlQpfL2eG9W3PbcM64+vlTKVWx/6jaSxadZDTSdnX3eu7XduqqXoJiam13hO8tLSMg4fjAejbzJPudm1DiAwPpaKykl/Wbef7pWsAuHvyqCZTuGzyrbE4OzmQnHaezTv2WzocIVoUVxcnHrhnAgCff/0zhUWm2yGiJci+eIlHn3uDtZt3oVGreebRe/jHEzOwsal7HRFT6BTZFqj6ori07PrbczU1qVcql1+9XZi1lYZgfzeG3BLO0N4RWFmpOZ9dgL1d1QwyKaYmRMtSr6Q7LS2Nc+fOGX7eu3cvTz31FJ9//rnJAhNC1J6vlzMTYjsR2ycCJ0dbiorL2bw7gZ/XHyHjQvVtsQBCg/2xtrKiqLiE85kXanWdA0dOUl5RiZ+PJ6GtAkz5FCxi/JXR7i+/W0H2xUt4ebgxOrafZYO6ipOjA1MnDAPgqx9kbbe4Memf6+a2MYMICfYnr6CQBT/8Yulwmoyj8We474lXiE9IxtXFif++/iy3jxtqseKSUDVK7OHuglar5fTZFIvFUR/6ke5WQTVXLg8P9WbSiGg8XB2wd6hKunfHnan1F+JCiKavXkn3XXfdxZYtWwDIzMxk2LBh7N27lxdeeIH58+ebNEAhRO2oVCrahnhzx5iu9IoOwdpKw4XcQlZuPMr6HScpKCw1Ot/Kyoqw0ECg9lPM9VvE9OnR2aIfvkwldmBPHOztqLwyHf/OiSOwtdAozrVMGT8cJ0d7ElPSWbt5p6XDEU2c9M91Y2VlxZMP3AHAT79sJO1KcnQz+23978x+/k1yLuXTJjSIBf+da5HtE/9KpVIZtg47fjLRwtHUTVp6FnD9PbrdXRy4bXhn/Lw9ADh2MoVVW09QUtq8RvWFEDWrV9J97NgxevasWvO4ZMkSOnbsyM6dO/n+++9ZuHChKeMTQtSRlUZNTFQQd47tSmQbX1QqSEzLYdGqg+yOS6asvNJwrmFdd+KNk25FUQxbhTX39dx6jg72hoJqzk6OTBg9yLIB1cDZyYHpd4wD4NOvl/H/7d13eJRV9sDx75Rk0nsPIYUAgQChR3oLUpRixYqylt8iuuuiu4oF7KxlXVeXBUUR2yrqKqAiCJFQQ28BQgkkpJAO6X3m/f2RZDCSQBJmMpPkfJ5nHs3MO++cN5Nwc+bee05FRfOL5YnOR8bnlhs2pB/DBvelpkbPex+usnQ4FlOj1/PPZf/l1X+uoLqmhrEjBvHB289aRXuueu11X3f9TPeVenRD7ZLzyJ6143J5eRnpWQV8s/6wsbq5EKL9alXSXV1djU6nA2DTpk1Mnz4dgIiICDIzM00XnRCi1RzsbRkzNJxbJ/Un0NcVg0HhUGIGX/54gGOnMzEYlBZVME9JPU9WTj62NloGW8Gsh6nce9tU+vYO54m5d+Ngb3f1J1jAbdNj8PPxJC+/gP9+t8HS4QgrJuNz6/zpoTvQqNVs23WIPQePWTqcNldYVMJfnnubr9dsBODBe2by6jOPWN2/iZdmuttP0q3XG0g3znT7XuXoS7263V1scHexp6y8ih9+PcqBY+my3FyIdqxVSXdkZCTLli1j27ZtbNy4kcmTJwNw/vx5PD09TRqgEOLaeLo7cuO4SKaM7oWbsz0VldVs23eWb9Yfws2tdhlbc/bH1c9yD4zqhZ2dzqwxt6UAP28++MezTBrfNv1mW0Nna8Mjc24D4PNv1klVW9EkGZ9bJ6RrALdMGw90vhZiZ1LSeeDPL7Hv0HHs7XQsfu5RHrh7hsXbJjYmonsIarWK7NwL5LSTQmM5eReoqq7BRqvFz8frqsd7e9Ym3YVFxdw8KYoeId4oCuw5co51WxIpr5RWYkK0R636F/X111/n/fffZ+zYsdx5551ERUUBsHbtWuOyNiGE9VCpVAQHenDb1P6MGBSKzlbLxcIyTqTULlnLyy/gQkHjBdfq1Sfdwwd3jKXl7U3MmKFE9gyjvKKS5Z99b+lwhJWS8bn1/lDXQuxsSgZr13eOFmJbdh7g4fmvkpGVW/sB5NvPMnbEIEuH1SQHezu6hdT2V28vs931lcu7BPig0Vz9z24fr9oPw3PzLmKj1TDuuu6MGRqORqMmLfMi364/1GSBVCGE9WpV0j127Fjy8vLIy8tjxYoVxvsffvhhli1bZrLghBCmpVGr6dsjgLumDaJfzwB0Oh0uzi4AfL9+V5OfoJeUlnH42Gmg4+znbm9UKhV/eri24NOPv2wjKTnNwhEJayTjc+u5Ol9qIbb80+8oLum4LcQMBgMffbGGp19+j7LyCgZF9WLFvxYSHhpk6dCuqr3t627ufu563l5uAOTmF2AwGFCpVPTq5svNE/vh6mxHaVkVa2MTOJSYIcvNhWhHWpV0l5eXU1lZibt77RKYc+fO8c4773Dy5El8fHxMGqAQwvR0tlqGDwzl9qkDCOriD8CBhCS+/GE/hxIzLmtNtffgcfR6PV27+NElQH7HLaVf7+6MGzkYg0Hh3x99belwhBWS8fna3HTDWEKCAigoKuHjLztmC7Gy8gqee20pH36+GqitGfHOK/NxdXGybGDN1N72dae1YD83gKe7KyqVCr1ez8WC4t/c78gtk6IID/ZCUWDXoRTWb0ukQpabC9EutCrpnjFjBp9++ikABQUFREdH849//IOZM2eydOlSkwYohDAfN2d7Rl/XF4DSkkKqqvXsOpTC1z8fpKDo0iyPcWm5zHJb3CNzbkOr1bB7/1F27U+wdDjCysj4fG20Wq1xRcnXazYZlwZ3FOezcvm/J15j8459aLUaFjw+h/lz70ar1Vo6tGbr06s26U48nUJNTc1Vjra81PTaAoZBTfTo/j2tVounuysAufkN963b2miZMKwHo4d0Q6NWcS7jIt9uOEx2XnFjpxJCWJFWJd0HDhxg1KhRAHz77bf4+vpy7tw5Pv30U959912TBiiEMK/6CublZUWMjQ7Hwc6GwuIKvt+YQGZOIQaDgfgO1iqsPesS4MOt0yYA8N6Hqy5blSA6Nxmfr92wwX0ZPqQfer2ef3/UcVqIFRWX8tD8V0hKTsPD3YUlrz/F9EmjLR1WiwUF+OLs5EhVVTVJyemWDueqUutmuoObubwcwNvTDbg86YbarUa9w/24aWI/XJzsKCmtZE1sAkdOnJfl5kJYsVYl3WVlZTg7OwPwyy+/cPPNN6NWq7nuuus4d+7qVZCFENajZ12v7rSMbLr6u3LblAH4eDpRWVXDD5uP8euOw+RfLMTB3o7+kT0sHK0AuP/OacaCTz9t3GbpcIQVkfHZNB576A40Gk2HaiG2bddBLlwswt/Xi4//tYh+vbtbOqRWUavVREaEAda/r7uyqpqsnHyg+TPdAN51xdSuVKHdy8OJWyZFERbkicGgsPNgMr9sP0FllfXP/gvRGbUq6Q4PD2f16tWkpaWxYcMGrr/+egBycnJwcXExaYBCCPPycHfFy8MNRVE4k5KOvZ0N08b3IbSLBwaDwv/W7QBgcP9e2NraWDhaAbUFn/5wV23/5Q8+/Z6y8goLRySshYzPphES5M8tN3asFmLbdx8CYPL44fh4e1g2mGvUpy7ptvZ93RmZOSiKgpOjPe6uzs1+nrGY2lXaoulstUwc0ZORg8JQq1Ukp1/g2/WHZLm5EFaoVUn3woULefLJJwkJCWHo0KEMG1bb3/aXX35hwIABJg1QCGF+Pepmu0+dSQXARqth4ogI+vb0JyO9tkq2l5c/BoMsXbMWt9w4nkB/H/IvFvL5Nz9bOhxhJWR8Np0/3D0dF+e6FmI/b7F0ONeksqqa3fuPAjDquv6WDcYE6iuYJyRad9JdXxMgKNAPlUrV7OfV9+pubHn576lUKvr08GdmTF+cHXUUl1by/cYj/PDrUc5lXJAl50JYiVYl3bfeeiupqans27ePDRs2GO+fMGEC//znP00WnBCibdTv6z515tLyU7VaRWQ3b/Lyc2u/tnXl563HqaqWpWvWwMZGy7w/3AbAf79bT07uBQtHJKyBjM+m4+rsxIN1LcQ++Oz7dt1CbP+h45RXVOLl6UZE9xBLh3PNeveonenOyMzhYoH19qyubxcW3IKl5XCpV/eVlpdf9hxPZ26d3J8eId6oVJCRXcjPWxP58scDJJw6L2O3EBbWqqQbwM/PjwEDBnD+/HnS02sLWQwdOpSIiAiTBSeEaBv1M92n62a66+3efxRFUQjuEoCrizNpmQWs2XSU0rJKS4QpfmfsiEFERXansrKK9z/9ztLhCCsh47Pp3HTDOEK7BlDYzluIbatbWj4qekCLZlytlYuzIyFBAQAcO3nWwtE07bcz3S1xpUJqV6Kz1TJ+WA/umjaIqIhAbG00FJVUsGN/Mp+v2cfOA8kUlch2JCEsoVVJt8Fg4KWXXsLV1ZXg4GCCg4Nxc3Pj5ZdfxmCQSrpCtDc9ugUDcCYlvUELlvpWYWNGDGDahD7Y62zILyjl+41HuFBQapFYxSUqlYrHHpwFwM+xOzmZJIWyOjsZn01Lq9G0+xZiBoPBuJ+7IywtrxfZDvZ1t7RHd736me6r7eluirOjHcMGhHDvzCGMGhyGm7M9VdV6jpw8z5c/7mfDtkTO5xTK0nMh2lCrku5nn32Wf//73/z973/n4MGDHDx4kNdee4333nuP559/3tQxCiHMLMDPCwd7O6qqa0hJq+0pqtcbjH2ghw/uh6+nMzdd3w83Z3tKyqpYvSmB9KwCC0YtoHZv48Qx0SiKwnsfrpI/otqIoihW2a5NxmfTu25QX4YPjUKv1/Peh+2vhdjJpHPk5RfgYG/HoKhelg7HZPrU7es+esJ6Z7rTMlo50+1Vu6e7rLyC0tLyVr++jVZDZHd/Zt0wgKljetPFzw1FgeT0C6yNPcr/Nhzm5Nkcq/y3TIiOplVJ9yeffMKHH37I3Llz6devH/369eORRx5h+fLlrFy50sQhCiHMTa1WX1pifra2cNqxk2coKi7F2cmRyF61f9y4ONkxc2Jf/L1dqKrWsy7uOCfP5lgsblFr7pxbsbXRsv9wIjv2HLZ0OB1edXUNr7z9Ef98/wur+5BDxmfz+NNDs9BoNGzffYg9B9pXC7Gtuw4CED2wT4fqQNGnblw6fvKsVSaNRcWlXCysrSIe1MKZbns7HU6O9kDLl5g3RqVS0TXAnRvHRXL71AH0DvdFq1GTd7GUzbtP8/nafexLSKWsvOqaX0sI0bhWJd0XLlxodG9YREQEFy5IMR8h2qNLFcxrlyjH1y0tv25QH7QajfE4O50NN46LJDzYC4OisHn3afYmpFpd8tGZ+Pt6cfuMiQD8+6OvG2wREKZVVFzKX57/B+s27WD1T3GcSUm3dEgNyPhsHsFd/Ll12gSg/bUQ277rEAAjO9DScoDQroHY2+koK68gJe28pcO5TP0st7enOw72di1+fmuKqTWHh6sDo4eEc8+MwURHBePoYEt5RTX7jqbx+dp9/LrrNHkXS0z6mkKIVibdUVFR/Pvf/77s/n//+9/069fvmoMSQrS9SxXMa4up1e/nHjbk8t9pjUbNhGE9GNC7CwD7j6axeXeSVc42dBb33XEjbi5OnEvLZO36rZYOp0PKyMzh4SdeZf/hEzjY2/Hmi48THhpk6bAakPHZfP5wV10LsXPtp4VYZnYeSclpqNUqRgyNsnQ4JqXRqOndMxSwzn3dqfX7ubu0bJa7XmuLqTWXnc6GAb27cNe0QcQM74GvpzMGg8Kp5By+XX+YNbEJJKfnS6tQIUxE25onvfHGG9xwww1s2rTJ2AM0Pj6etLQ01q1bZ9IAhRBto76Y2umzqeTkXeTUmVRUKhXXDerT6PEqlYroqGCcHXVs23eGU8k5lJZVcv3ICHS2rfqnRVwDJ0cHHrhnJv/4z+d8+PlqJo0bhmPd8kRzO3z0FFviD3DnzZOM/WU7mqOJZ/jbi//iYmExPl7uvPXi48YPqqyJjM/m4+LsyEP33sQ//vM5H3z2PTFjonFxdrR0WFe0rW5peb/ePXB1cbJwNKYXGdGN/YdPkJB4humTx1g6nAZSW7mfu55X3b+lOXnmXaGiUasJD/YmPNib7LxiEk6d52xqPpk5RWTmFOHsqCMqIpDI7i3rNS6EaKhVM91jxozh1KlT3HTTTRQUFFBQUMDNN9/MsWPH+Oyzz0wdoxCiDYR2DUCr1VBcUsb36zYD0LtHKO5uLld8Xu9wP6aM7o2NVk1GdiGrNyVQXCotxSxh5pQxdO3ix8XCYj75+kezv56iKHz1/S/Me+p1vvxuA08s/CelZa0v+mOtft22l3lPv87FwmJ6dOvKh+88b5UJN8j4bG4zp45tVy3EttUtLe9IVct/q76YmjXOdNcvL+/ayqT7UgXzAlOFdFW+Xs7EDO/JXdMHMaB3F3S2WopLK9m+/yy/7jqNXjogCNFqre7THRAQwKuvvsr//vc//ve///HKK69w8eJFPvroI1PGJ4RoIzY2WkK7BgLw7dpNQONLyxvTNcCdGTF9cbC35WJhGd//cpjcC7InrK1ptVoefeB2AFZ9/wuZ2Xlme62KikpeeOMD/vXBl+gNBmy0Wk6fTWPh6+93mG0GiqLw+bc/8+xr/6GqqpoRQ6NY+uYCq5/Nl/HZfLQaDX9++E4Avlkba9UtxIpLyjiYcBLouEl3ZF3SnZx6nuKSMgtH01D9z0bXLq1Lur293ADzLS+/EicHHdFRwdwzYzDDB4SiVqk4nZLL+q0nqK5pP/UMhLAmrU66hRAdT30xtZK6FiXDm5l0A3i5O3HzxH54uDpQVlHNmtgEzp2Xwk1tbWR0fwb2i6CquoZlK/9nltc4n5XLw0+8xi9xu9Co1fzlj3ex9M2nsbW1Yeeew7y7/CuzvG5bqqmp4fX3PmHJR18DcOu0Cby+8E+tKojUni1ZsoSQkBDs7OyIjo5mz549zXreV199hUqlYubMmQ3uv//++1GpVA1ukydPNkPk5hM9qA8j6lqIWfPPevy+I+j1ekKCAlq9xNnaebi5EOjnDUDiqWQLR3OJwWBodY/uepcKqVluHLXRaugXEcDk0b3QatSkZV7kx1+PUVFZbbGYhGivJOkWQhj1rNvXDeDh7kLP8OArHH05J0cdM2L6EujrSk2NgfVbEzl2OtPUYYorUKlU/OmhWQD8EreL4ydN28N29/6jzPnTi5w+m4q7qzPvLv4rt8+YSGRENxY++RAAX6/ZyLc/xJr0ddtSaWk5Ty56hzU/b0GlUvGXP97FE4/cg0bTuYbMVatWMX/+fBYtWsSBAweIiopi0qRJ5ORcuU1gSkoKTz75JKNGjWr08cmTJ5OZmWm8ffnll+YI36weq2shtmPPYXbvP2rpcBq1vYMvLa8XaezXbT1LzPPyC6iorEKj0eDv69Wqc9SvqMnNLzBhZK3TNcCdG8dHorPVkp1fzJpNCZTINjIhWqRz/QUhhLii7t0u7VMdNrgfanXL/4nQ2WqZOqY3PUN9UBTYtu8suw6lSAXUNtQzPITJE4YD8N6Hq0zSzk1RFD77+ifmL3ybouJSevUI5eP3FjGw36X2VBNGDeGP998CwD+XfWFsO9eeZOfm839PvsbuA8ew09ny+sLHjO3YOpu3336bhx56iDlz5tC7d2+WLVuGg4MDK1asaPI5er2eu+++mxdffJGwsLBGj9HpdPj5+Rlv7u7WvVy/Mb9tIfbu8q+sroVYdXUN8ftqf/86Wquw37PGfd31RdQC/bzRaltXWLS+evnFgiKqqiw/s+zn5cKMmL442ttysaic7zcd4WKhdS3pF8KatehfgptvvvmKjxcUFFxLLEIIC+v+m/ZHzd3P3RiNRs3Y6HCcnXTsS0jjUGIGGdmFjBnSDS+PjldB1xr98b6b+XXbXg4dPcWWnQcYO2JQq89VVl7BK29/xObt+wCYNmkUTzxyLzpbm8uOnX37DaRlZPPTxu08t3gp7//jGatrq9WUE6dT+OsL/yLvQgGe7q689eLjRHQPsXRYzWLq8bmqqor9+/ezYMEC431qtZqYmBji4+ObfN5LL72Ej48PDzzwANu2bWv0mLi4OHx8fHB3d2f8+PG88soreHp6NnpsZWUllZWXZtSKiopadB3m9Ie7prP+152cPZfBmp+3cMuN4y0dktGho6coKS3H3c2FyJ7dLB2OWUVG1H64c/TEGRRFsYoK2/XtwoJaubQcwM3VGRutluqaGvIvFrZ6xtyUPFwdmDmxHz/FHaOgqJzVmxKYOqY3vl7Olg5NCKvXomksV1fXK96Cg4OZPXu2uWIVQpiZo6M9k8ZdR49uXZtsFdZcKpWKwX26MmFYD2xtNOReKOF/vxwm/mCyFGJpA77entx18yQAlqz4murqmladJy0jiwcff5nN2/eh1Wr422OzWfDnOY0m3FD7vj/12H0M7BdBWXkFTy56h/wLha2+jraybddB5v51MXkXCggLCeTDd55vNwk3mH58zsvLQ6/X4+vbMGnw9fUlK6vx4mHbt2/no48+Yvny5U2ed/LkyXz66afExsby+uuvs2XLFqZMmYK+iZnixYsXN7iOoCDr+QCnvoUYwPLPvqeouNTCEV1S3ypsxNCoDr8tontYV2xttBQVlxr3UVvatRZRg9p/S7296tuGtX0xtaY4120j8/F0orKqhh9+PUrqeeuJTwhr1aKZ7o8//thccQghrMQLf/s/k56ve4g3Ab6u7DxwljOp+Rw+cZ4zqfmMGhxGcKCHSV9LNHTPbVNZu2Er6edz+H7d5hYvk96++xAvvvkBJaXleHm48dpz8+jbK/yqz7Ox0fLac/N4+C+vkpqRxV9f/Bf/ef0p7Ox0rb0Us/p6zUbeef9LFEUhemAkrzzzCE6ODpYOq0UsPT4XFxdz7733snz5cry8mp6Ru+OOO4z/37dvX/r160e3bt2Ii4tjwoQJlx2/YMEC5s+fb/y6qKjIqhLvGVPG8N2Pv3L2XAYr/ruWx//vTkuHhKIoxqS7o+/nhtp/b3p2DyHheBJHT5y5pkTXVK61XVg9Hy93zmflkmvBYmqNsdfZMG1cH37ZfoK0rALWb01k3HXd6R7ibenQhLBaHfvjTyGEVXC0t2XiiAimjOmFk6OOkrJKft6ayC/bT1BaXmXp8DosRwd7Hrqndibuoy/WNHsmzmAw8NEXa/jrC/+ipLScfr278/F7i5qVcNdzdXbirZcex8XZkcRTybz01ocYrKzHq15v4O2lX/DPZf9FURRmTB7DWy8+3u4SbnPw8vJCo9GQnd1w5jA7Oxs/v8sTiTNnzpCSksK0adPQarVotVo+/fRT1q5di1ar5cyZxvfbhoWF4eXlRVJSUqOP63Q6XFxcGtysyW9biH37Qyzn0i1fOPJMSjpZOfnY2towdECkpcNpE9a2r7t+T/e1fgBgTcXUfs/GRsPk0b0ID/bCoCjExp/iyMnzlg5LCKslSbcQos0EB3gwa+oAoiICUKngbFo+q346wLHTmSYp9iUud+OkUYR2DaCouJSVX/1w1eNLSst4+uX3+PDz1QDcMm08//773/DycGvxawcF+PL6wj9ho9Wyecc+ln1inhZmrVFWXsFTL73LN3U96ef94Tae+tN9rS561NHY2toyaNAgYmMvVaE3GAzExsYybNiwy46PiIggISGBQ4cOGW/Tp09n3LhxHDp0qMnZ6fT0dPLz8/H39zfbtZjb0IGRjIzuX9dCbJWlw2FrfO0s99ABkVa7usTU+lhRBfPq6hoys/KAa9vTDeBVV0zNkm3DrkSjUTNhWA/69Kj9/d15IJndh8/JeC5EIyTpFkK0KRuthmEDQrnl+ii8PZyoqtazbd9ZVm9K4EKB9eyJ7Ci0Gg2PPVjbQuzbtbFkZDbd7in5XAYP/Plltu06hK2NlufmP8CTj9yLjU3rE9H+fXrwzF/mAPDZ1+v4YcPWVp/LVHLzLzL3r4vZsecwtjZaXnnmEe65bapVFGCyJvPnz2f58uV88sknJCYmMnfuXEpLS5kzp/b9nD17trHQmp2dHX369Glwc3Nzw9nZmT59+mBra0tJSQl//etf2bVrFykpKcTGxjJjxgzCw8OZNGmSJS/1mj32YG0LsZ1W0EJseydaWl6vPuk+k5xOeYVlW1llZOWiNxhwsLdr1YeVv1Xfqzs333r3TKtUKkYMDGVov9ruJwePp7NlT5J0LBHidyTpFkJYhJeHEzdN7MeIgaHYaNVk5xXz7frD7D58jhoptGZS1w3uy9ABkVTX1LB05beNHhO3Yx8P/uUVUjOy8PX2YNlbz3DDxJEmef3J44fzh7umA/D6e5+y79Bxk5y3NZKS03jw8Zc5daa2z/i/X3+KCaOGWCweazZr1izeeustFi5cSP/+/Tl06BDr1683FldLTU0lM7P5y6k1Gg1Hjhxh+vTp9OjRgwceeIBBgwaxbds2dLr2PSPbtYufsYXYiv+utVgcOXkXSTydgkqlYmR0f4vF0dZ8vD3w9nRHbzBw4nSKRWOp388dFOh7zR/k1RdSy80ruNawzEqlUjEwMogxQ7uhUsGJszn8suOEjOVC/IYk3UIIi1GrVfTtGcCsqQMJCfTAoCgcPJ7O1z8fIj2rwNLhdRgqlYrHHpqFSqUiduteEhIv7Z/V6w0sXfktC15ZQll5BQP7RbDi3UX06hFq0hgevGcmE8dGo9freebVJaSktf3e1/h9CfzfE6+Rk3eR4CB/lv/zuRbtU++MHn30Uc6dO0dlZSW7d+8mOjra+FhcXBwrV65s8rkrV65k9erVxq/t7e3ZsGEDOTk5VFVVkZKSwgcffHBZhfT26p7bpmCj1XLk+GkOHzttkRi27z4EQGTPMDzcXS0Sg6VYy75uY+XyayyiBrWF1MB6l5f/Xq9uflw/IgKNWkVK+gV+ijtOZVXrOmcI0dFI0i2EsDgnRx2TR/di0sgIHO1tKSqp4MfNx4iNP0V5RbWlw+sQwkODjDPX737wFYqiUFhcwhOL/smnq34C4M6bJ/Gv157Ew830xapUKhXP/uUB+vTqRnFJGU8u/CcFhcUmf53GKIrCdz/+yl8XvWP8YOGDfzxLoL9Pm7y+6By8PNyYGjMCgP/+72eLxFC/tHxkJ1paXu+3/botKc0EPbrr1RdSy7tQYLFClMnnMojbsR+9vnmvHxrkyQ3jIrG10ZCZW8Ta2AQpmCoEknQLIaxIaJAns24YQJ/utUVZTqfk8tVPBzhxNlsKs5jAw7Nvwk5ny9ETZ1jx37X84U8vsXv/UXQ6W17428P86aE70Go0Znt9na0Nbyz8EwF+3mRk5fLUS+9RVWW+D1VqamrY8Gs8s+ct4s0ln6E3GJgyYTjvvPIELs6OZntd0XndecskVCoVW+MPkpLatpWcy8or2HcoEYDR1w1o09e2BsZiaolnLDpepJqoXRiAl4crKpWKmhp9m31I+XsLXl3Cglf+zZw/vcCBIyea9ZwAH1emT+iDvZ0N+QVlrN54hMLicjNHKoR1k6RbCGFVbG20jBwcxk0T++Hp5kBlVQ1xu5P44dejFBSVWTq8ds3b0517bpsCwIefr+Z8Vi4Bft4sf/tZJo27vCK1Obi7ufCPFx/HydGeI8dP8+o/V5j8D+TyikpWrf6F2x54mhfe/ICk5DTs7XTMnXMrzz/x4DUVhhPiSoK7+DN6WG3C+8X/1rfpa+/ef5TqmhoC/X0I6RrQpq9tDXp2D0Gj0ZB/sZCsnHyLxWFcXm6CfuFarda48sgSxdRKSss4V7cV6PTZNOY99TrPvvYfMrPzrvpcL3cnZsb0xcXJjuLSSlZvTCD3Qom5QxbCaknSLYSwSr5eztw8KYrr+gej1ag5n1PE1z8fYt/R1GYvcxOXu+uWKcY2NNEDI1nx7kK6h3Vt0xhCugbw2rOPotFo+CVuFyv+u8Yk571QUMQHn37PzNlP8M77X5KVk4+7qzP/N/tmvv/0LWbffoNUKBdmd8+tUwFY/+vONk2Utv2manln/Dm309nSI6y2NZ2l9nWXlpaTf7EQMM3ycrhUTC3HAsXUziSnA7VbJ26+YRxqtYpft+3ljoef4cPPV1NxlUrxrs72zIzpi6ebI+WV1ayNPUpGdkEbRC6E9ZGkWwhhtTRqNf17deH2qQMI8nfDYFDYl5DGN+sPcVFmvVvF3k7HsjcX8Nqz8/jHS/NxdXaySBxDBvTmr/PuBeDDz9ew4df4Vp8r/XwOby75jJvue5KPv1xLUXEpXQJ8+Ntjs/nuk7e4/85pFrtO0fn06dWN/n16UFOj5+vVG9vkNWv0enbuPQLAqE64tLxepLFf91mLvH7a+dr93B7uLjg5OpjknD7GCuZtX0wtKaU26e4RHsxfH53NyvdeYEDfnlRVVfPRF2u48/+eZdPWPVdcreRgb8v0CX0I8HGhukbPT3HHOZt29ZlyIToaSbqFEFbPxcmOqWN6EzO8B/Y6GwqKyvll2wmqpR1JqwT6+zBu5GA0GssOATOmjOHuW2uXu7/6zxUtrvh84nQKzy3+D7MeeprvfvyVqqpqenUP4dVnHuGrDxZz09Rx2OlszRG6EFd0z221s93fr4ujpNT8HxAeTTxDYVEJzk6O9IvsbvbXs1aWrmBuyv3c9bzqiqlZYnn56bOpAISHdgGge1hXlrz+FK888wh+Pp5k5eTz/OKlzHvqdeOxjdHZapk6NpLQLh4YDAq/bD/J6ZTcNrkGIayFJN1CiHZBpVIRHuzNbVP642Bvy8Wicnbst8xshjCdR+bcyuhhA6muqeHpl94l/XzOFY9XFIXd+4/y2II3mfOnF4nduheDQeG6wX1Z8vpTfPSvhYwfNcTiHyiIzm3Y4L6EBQdSWlbO6nVxZn+9rfEHABgxtJ9ZiyFau/qZ7pNJ58xapLEp9fu5TbW0HC5VMM/Ja/uku355effQION9KpWKCaOG8OX7r/LgPTPQ6Ww5mHCS+x97gdff+6TJgm9ajZqJIyKICKvtGvHrrlOcy2gfrdCEMAX5q0QI0a442NsyYVgPVCo4cTZHPi1v59RqNS/87WEiuodQUFTCky+8Q1Fx6WXH1ej1/BK3i/sefYHHn/sH+w4dR6NWM3n8MD77z0v88+X5DOwX0Sn3sgrro1arueuWyQCsWr3RrAmgoii/2c/deZeWAwT6e+Pm4kR1Tc0VZ17NxTjT3cXfZOc0Li9v45lug8HAmbrl5eG/Sbrr2dnpeODumXz1wWvEjB6KwaCwel0ctz/4NF+v2UhNzeX9udVqFWOGhtM92BtFgV92nOR8TqHZr0UIayBJtxCi3Qn0dWVgZO0fAVv3JkkrknbO3k7HG4v+hI+XO+fSMnnm1SVUV9f+wVZeUck3azZx+wNPs+j19zl9NhU7nS23z5jINyteZ9FfH270D0IhLO36sdfh7elO3oUCNmxufc2CqzmXnkX6+RxstFqiB/Ux2+u0ByqVyjjbnZDY9kvM63t0dzXDTHduGxdSy8jKpbyiElsbLV2ucD1+Pp68vGAu/3njabqHBVFcUsY/l/2X2fMWsefgscuOV6lUjL0unOAAd/R6A+u3JkpVc9EpSNIthGiXBkUG4e/tQnWNgY07TkpF83bO29Odt158HAd7O/YfTuTv767kw89Xc9N9T/L2si/IzM7D3dWZh2ffxOpP/8Ff/ngX/r5elg5biCbZ2Gi546brgdr2YQaDef6N2la3tHxgVASODvZmeY32xFL7uhVFudQuzIR7un2865eXt+1S7DPJaQCEhXRp1paFAX178vG7L/C3x2bj6uJEcup5/vzMWzz10ntkZDbcNqRRq5k4oif+3i5UVev5Ke6YFEcVHZ7Fk+4lS5YQEhKCnZ0d0dHR7Nmz54rHv/POO/Ts2RN7e3uCgoL4y1/+QkVFRRtFK4SwFmq1ignDe2BnqyXvYim7DqdYOiRxjbqHdeWlp/+IWq1i3aYdfPTFGgqLSgj08+av8+7lu0/eYs6d03F1kUrkon2YMWUMTo72nEvLZPvuQ2Z5jW115x3dyZeW1+vTq76Cedsm3RcuFlFWXoFarSLAz9tk562f6S4rr6C0tO1WdSXV7efuFtKl2c/RaNTcNHUcX3/4d26fEYNGrWZr/AHufPhZlq78lrLyS3+va7UapozphZe7IxWVNfy0+RjFpVduQSZEe2bRpHvVqlXMnz+fRYsWceDAAaKiopg0aRI5OY0X0vnvf//L008/zaJFi0hMTOSjjz5i1apVPPPMM20cuRDCGjg56Bh3XW2l3oSTmaRIUZZ2b8TQKObPvQe1WkVE9xBeeeYRVn34d26+cbxUIhftjqODPTffOB6Az7/92eTnv1BQxNG6ZdQjo/ub/PztUa8eoahUKrJy8sm7UNBmr3suPRMAf19vbG1tTHZeB3s74wqGttzXffps7Ux397CWb99xcXbkL3+8m0//8xJDBvSmuqaGT1f9xKyHFrD+153GFmO2NlpuGBuJm7M9JWVV/Lj5KOUVVSa9jpaqrKpm266D5F+QvebCtCyadL/99ts89NBDzJkzh969e7Ns2TIcHBxYsWJFo8fv3LmTESNGcNdddxESEsL111/PnXfeedXZcSFExxUc6EG/ngEAbN51mpIy+aS8vbvlxvFs/PY/rPjXQiZIJXLRzt0+fSI2Wi0Jx5Na3BbvanbsPoSiKPQMD8bH28Ok526vHB3sCQsOBOBYG/brNsd+7nr1xdRy2jDprl9efi01M8KCA/nXq0/y9+cfI8DPm7z8Al58czkPP/Eq+w4dR1EU7O1suHFcJE4OthQWV/BT3HEqqy4vwmZuNTU1rF2/hdsfeIq/vfguf33xX1fsPy5ES1nsL5mqqir2799PTEzMpWDUamJiYoiPb7zgyPDhw9m/f78xyT579izr1q1j6tSpTb5OZWUlRUVFDW5CiI4lOioYbw9HKqtqiN15CoNBBsr2zsHeTiqRiw7B08OVqTEjAPji23UmPXf9kvXOXrX89yyxr7u+cnmQCfdz17tUTK1tku7SsnIysmo7g1xroUqVSsWY4QP57/uv8sf7b8HeTsfRxDM8tuBN/u/J14jfl4Cjgy03juuDnc6GvIulrN+aSE2N3hSXclUGg4GNcbu564/PsfhfK42t2RJPJXPkeFKbxCA6B4sl3Xl5eej1enx9G34i6OvrS1ZWVqPPueuuu3jppZcYOXIkNjY2dOvWjbFjx15xefnixYtxdXU13oKCpMqtEB2NRqMmZnhPbLQaMnOL2H8szdIhCSGE0V23TEalUrFt1yFSUs+b5JwVlVXsPlBbHVqS7oYiI8KAtt3XnWZsF2aGpNurbZPu+lZh3p7uJquhobO14b5ZN7Lqw8XcMm08tja1qz/mP/82D/z5JY4cS+SGMb2wtakdx3/ZcRK9mYoPQn2rvUPc9+gLLHx9GWkZ2bi7OvPnh+9k8vhhAHyzdqPZXl90Pu1qzV5cXByvvfYa//nPfzhw4ADfffcdP/30Ey+//HKTz1mwYAGFhYXGW1qa/DEuREfk6mzP6CG1sxv7j6aRkV1g2YCEEKJO1y5+jBk+EDDd3u69B49TWVmFr7dHq/bddmT1M92Jp5Kp0bfNjGlq3fLyIDMsL/du417d9UXUwkObX0Stubw93XnykXv538o3ufPmSdjpbEk8ncJTL73H/OffxNWuEpUKUs9fZPOu02ZZ4r3/cCIPz3+Vv734L5KS03B0sOfh2TfxzYrXueOm67nrlskAxG3fT06u1IoRpmGxpNvLywuNRkN2dnaD+7Ozs/Hza/xTwueff557772XBx98kL59+3LTTTfx2muvsXjx4iZbceh0OlxcXBrchBAdU/cQbyLCfACIjT9l8YIsQghR755bpwCwYXO8cQnrtdi++yAAI6/rL1sxfic4yB9HB3sqKqs4U5dAmlONXm9sixVsjpluz/q2YW00022C/dxX4+Xhxp8euoPvVr7J7Fk34GBvR1JyGm8tWckvv6wl+WwSp5Jz2L7/rMkS72Mnz/KnZ97k0aff4OiJM+h0ttx7+1T+t/IN5tw53ViwrntYV/r36YneYOD7dZtN8tpCWCzptrW1ZdCgQcTGxhrvMxgMxMbGMmzYsEafU1ZWhlrdMGRNXe9AKXYghAAYMSgMdxd7ysqr+XVXkvzbIISwCpER3ejfpyc1NXq+XnNty1YNBoNxP/fo6waaILqORa1WE9mzdol5W+zrzszOo6ZGj05na0yQTcmnjWe6T9cn3W2wgsLdzYW599/Kd5+8yQN3z8DZyYHzmTls3R7H6jXfsnrdFuIPXltBvKTkNJ566V0efPxl9h48jlar4dZpE/h2xes8Muc2XJ0vX0J/+4zamlOr18VRWVV9Ta8vBFh4efn8+fNZvnw5n3zyCYmJicydO5fS0lLmzJkDwOzZs1mwYIHx+GnTprF06VK++uorkpOT2bhxI88//zzTpk0zJt9CiM7NRqshZkRPNBo1aZkXOXzCNPsnhRDiWt1zW+1s9/c/baaktKzV50k8lcyFi0U42NsxoG9PU4XXobRlv+609LoiagG+l00OmYKxkFobJN0Gg8G4OsCcM92/5+rsxIP3zOT7lW/xx/tvwc3FieLiInbGb2Pha+/w7kfftTj5TTufzQtvvM/seYvYGn8QtVrFDRNH8vWHf+eJR+7By8OtyeeOGjYAX28PCopK2LRl9zVenRCgteSLz5o1i9zcXBYuXEhWVhb9+/dn/fr1xuJqqampDf7xeu6551CpVDz33HNkZGTg7e3NtGnTePXVVy11CUIIK+Tp5siIgaFs3XuGPYfP4e/jgq+ns6XDEkJ0csMG9yUsOJCz5zJYvS6Oe25ruvvKlWzdVbu0fNiQvtjYWPRPOat1qYK5+duGmXM/N1ya6b5wsYjq6hqzvudZOfmUlVdgo9Wapf3Z1Tg62nPfrBu5fcZEvv9pMytX/URxcQlffvsDP2/cwn2zbmDmlDHY2emaPEdO3kU+/nItP2zYhr5uT//4UUN46J6ZhHQNaFYcWo2GW24cz38+/pav12xkaswI2cYhronFC6k9+uijnDt3jsrKSnbv3k10dLTxsbi4OFauXGn8WqvVsmjRIpKSkigvLyc1NZUlS5bg5ubW9oELIaxar26+hAV5YlAUNu04aZG+n0II8VtqtZq76/Z2r1q9kapWLlvdvusQIFXLr6R33fLy1IwsCotKzPpaqXUz3ebYzw3g5uqMjbY20c67UGCW16h3+mzt0vLQ4AC0Wst9oGNvp+OuWyaz9tO3uGnaZBwcHCkoLOJfH3zJzXP+xuffrKO0rLzBcy4WFPHu8q+47Q9/Y/W6OPR6PcMG92Xle4t49ZlHmp1w15s+eQy2tjacOpPKkWOnTXl5ohOyeNIthBDmoFKpGDM0HGdHHcWllWzZI/u7hRCWN3FMND5e7uRdKGD95vgWPz/9fA5nz2WgUasZNrifGSLsGFxdnOha1zP7+Enzznabs0c31I5nXp5ugPmLqSW1QRG1lrCz0/HXubezYP48hl03EicnJy4WFLFkxTfcfP9fWfHftWTl5LP8s++59Q9P8eV3G6iqriEqsjtL31zA2y/Pp2d4SKte29XF6VL7sB82mfCqRGckSbcQosPS2WqJGdETtUrF2bR8Es9kX/1JQghhRjY2Wu64aRIAX3z7c5PdV5qyra5qef++PXBxdjR5fB1J397hQG3FeHMy9ug2U9INbVdMzdqSbqj90GH8sAgmTxjBTTNvZ/SosQT4+VBUXMryz77npvueZMV/11JWXkHP8GDefnk+S99cQP8+Pa75tW+bXltQTdqHiWslSbcQokPz9XRmaFQwADsOJJNfUGrhiIQQnd30yaNxcrQnNT3LWIW8uWRpefPdOm0CAL/E7ebUmVSzvEZ5RaVx9jmoi/n2QLdVMTVrTLoB1GoVE4b1oGuAB6Gh4UydOpO/Pno/YcGBQG2buNeencfH7y5i2OC+Jtt/HR4axIC+te3DvvtJ2oeJ1pOkWwjR4UVFBBDk745eb2DTjpNU1+gtHZIQohNzdLDn5hvHA/D5tz83+3mFxSUcPnoKgJHR/c0RWocS0T2EiWOiURSF/6z42iyvkX6+dgWVq4tTo62nTMW7fqbbjMvLy8oryMjMBSA8tIvZXqe1NBo1k0ZG4OvpTHWNgZJqe5a88Qxfvv8qny99mXEjB5ul2JmxfdjPcVRUVpn8/KJzkKRbCNHhqVQqxl8XjoO9DReLytmx3/zVbIUQ4kpunz4RWxstCceTjIn01cTvPYLeYCAsJJBAfx8zR9gx/N99N6PVath94Bh7Dh4z+fnP1RVR62qmImr12iLpPpuSgaIoeLq74u7mYrbXuRY2NhqmjOmFh6sDZeXVrNuSiLe3F1oztg4eed0A/Hw8KZT2YeIaSNIthOgU7O1smXBd7f6uE2dzOJ2Sa+GIhBCdmaeHK1NiRgDNn+3eVre0fLQsLW+2QH8fbr5hHAD/WfFNi/fQX01b7OeGS8vLzVlIzbi0PMy6lpb/np3OhhvGReLiZEdRSQU/bT5GRWXrOgE0R337MICv12ySoqyiVSTpFkJ0GoF+bgyKrF0yt3XvGQqLy6/yDCGEMJ+7bp6MSqVi++5DJJ/LuOKxVVXV7NqXANTOvInmu/+OaTjY23Ey6Rybtu4x6bnN3aO7XlsUUktKsc793I1xtLflxnGRONjbcKGwjE07T5k1GZ42eTQ6nS2nz0r7MNE6knQLITqVQX264u/tQnWNnk07T6LXm3bWQwghmqtrFz/GDB8IwBf/W3/FYw8knKCsvAIvDzd6dQ9pg+g6Dnc3F+65rbY/+vuffNfq/uiNSUtv25nuvPwCk8/W10s6W590W99+7sa4ONlxw5hItBo16VkFHDiebrbXcnV2YvK42vZhX6+V9mGi5STpFkJ0KvUVUHW2WnIvlLL78DlLhySE6MTuubU2GdywOf6KS4frl5aPiI5CrZY/31rqjpsm4eXhxvmsXL5fZ5oq1IqiGHt0m3tPt5eHGyqViuqaGgqKSkx+fkVRSEquTVrbw0x3PU93R0YODgNgX0IqGdmFZnutW6fXVsPfsmM/2bn5Znsd0THJv9pCiE7HyVHHuOja/q1HTp7nXIb03hRCWEZkRDcG9O1JTY2eVat/afQYRVHYvqu2P7e0CmsdezsdD9w9A4CPv/yBktKyaz5nQWExxSVlqFQqsxe2s7HR4u7mDJinmFpWTj6lZeVotRqCu/ib/PzmFBHmS89QHxQFYneepKzcPBXGw0ODGBQVIe3DRKtI0i2E6JRCunjSt0ftHxabd52mpKzSwhEJITqr+tnu1eviKC65PBk8dSaVnLyL2OlsGRTVq63D6zBunDSKrl38KCwq4YsWtGprSv1+bl9vD+x0ttd8vqsxZ6/u+iJqIUEB2NhoTX5+cxs5OAx3VwfKKqqJjT+FwWCe/d23TqttH7bm5y3SPky0iCTdQohO67r+IXi5O1JRVcOGbSeorpb+3UKItjdsSD/CQgIpK69gdSNLn7fVzXJHD+rTJsldR6XVaJh7/60AfPn9L9ecvLZV5fJ69cXUzFHBvL1ULm+KjVbDxBE90WrUZGQXcuBYmlleZ+R1/Y3twzbG7TLLa4iOSZJuIUSnpdGomTiiJ3a2WnIvlLBh+wkprCaEaHMqlYq7b6md7V61euNlhb62ydJykxkzfCB9e4dTWVnFR5+vuaZz1e/nDupi3srl9cw70123nzukfRRRa4yHqwOjh3QDYN/RNNKzCkz+GlqNhlum1e7t/mZtrLQPE80mSbcQolNzdbZnypjexuqnm3eflkFUCNHmJo6JxsfLnfyLhazfHG+8Pzs3n1NnUlGrVQwf0s+CEXYMKpWKeX+4HYAfftlKSur5Vp8rta5yeXBg2+yB9vbyAMyzp/tS5fL2OdNdr0eoDxFhtfvrY3eeotQM+7unTRplbB92WNqHiWaSpFsI0en5ejkzaVQEapWKpHN57DyQLIm3EMCSJUsICQnBzs6O6Oho9uxpXo/jr776CpVKxcyZMxvcrygKCxcuxN/fH3t7e2JiYjh9Wv5ohdpCWXfcPAmAL7792dgWqr5qed9e4bi7uVgqvA4lKrI7o4cNwGBQWLryf60+T1p9j+42m+l2A0yfdFdUVJJ2vvZaurfT5eW/NXJQGB6uDpRXVhO786TJ93e7OjsxeXxd+7A1G016btFxSdIthBBAkL87Y6+rrWiecCqTg8czLByREJa1atUq5s+fz6JFizhw4ABRUVFMmjSJnJycKz4vJSWFJ598klGjRl322BtvvMG7777LsmXL2L17N46OjkyaNImKigpzXUa7Mn3SaJydHEhNzzIm2/VVy0fK0nKT+uN9t6BWq9gaf6BVs5V6vYH0ukS1rfZ0e3uZZ3n52XMZKIqCu5sLHu6uJj23JWi1Gq4f2RMbrZrzOUXsO5pq8te4bXptQbWtOw+QlSPtw8TVSdIthBB1eoT4MHxAKAB7jpwj8Uy2hSMSwnLefvttHnroIebMmUPv3r1ZtmwZDg4OrFixosnn6PV67r77bl588UXCwsIaPKYoCu+88w7PPfccM2bMoF+/fnz66aecP3+e1atXm/lq2gdHB3tuvmE8AJ9/s47S0nL2HzkBwKjr+lswso4nNDiQG6+v/WBoyYqvW7y6KSfvAlXVNdhotfh6e5ojxMv41C0vN3Uhtfoiat3b+dLy33JzcWD0kNoP0g8cSyct07Tfs24hXRgU1auufdivJj236Jgk6RZCiN/oFxHAgF6BAGzdm0RyunyCLTqfqqoq9u/fT0xMjPE+tVpNTEwM8fHxTT7vpZdewsfHhwceeOCyx5KTk8nKympwTldXV6Kjo694zs7mtukx2NpoOXriDO9/+h01NXq6dvFrd72T24MH75mJTmdLwvEktsYfbNFz6/dzdwnwQaNpmz+n65eXl5aVU1pWbrLz1hdR6xbafouoNaZ7iDe9w2uX/sfGn6bUxK1B62e7pX2YaA5JuoUQ4neGRgUTEeaDosCmnafIzCm0dEhCtKm8vDz0ej2+vg33qvr6+pKVldXoc7Zv385HH33E8uXLG328/nktOWdlZSVFRUUNbh2dp4crU2JGAPDN2k2AVC03F29Pd+6YeT0AS1d+S42++W0j65Purl3aZmk51K6EcHSwByA3v8Bk5zW2C+tAM931hg8Mw9PNkYrKajbtNG3/7pHRte3DiopLpX2YuCpJuoUQ4ndUKhWjh4QTEuiBXm/g562J5F8stXRYQlit4uJi7r33XpYvX46Xl5fJzrt48WJcXV2Nt6CgjpcUNObuWyajUqmMX4+K7m+5YDq4e26bgquLE+fSMvnpl+3Nfl5qG/formdsG2aiJeaKolxaXt4Biqj9nlajrtvfrSEzt4i9Cabb363RqLnV2D5skxRgFVckSbcQQjRCrVYRM7wHft4uVFXr+WnLMYpKpNiT6By8vLzQaDRkZzesa5CdnY2f3+VJxpkzZ0hJSWHatGlotVq0Wi2ffvopa9euRavVcubMGePzmntOgAULFlBYWGi8paWlmegKrVtQoB9jhw8CwM3FiT69wi0cUcfl5OjA/XdMA+DDz1dTXtG8Jchp9T26A9umcnk9by83wHTF1HLyLlBcUoZGo+mwWxhcne0ZG137O3TweDqp5023v3vapNHY6Ww5fTaNQ0dPmey8ouORpFsIIZqg1WqYMroXHq4OlJVX81PcMcorZN+W6PhsbW0ZNGgQsbGxxvsMBgOxsbEMGzbssuMjIiJISEjg0KFDxtv06dMZN24chw4dIigoiNDQUPz8/Bqcs6ioiN27dzd6TgCdToeLi0uDW2fxwD0z8PFy546bJ7XZnuHO6uYbxuHv60XehQJWff9Ls56TmtG2lcvrmbqYWv1+7uAgP2xtbUxyTmvUrasXkd1r36tf409RUmqa/d0uzo5MnjAcgG/WbDLJOUXHJP+KCyHEFehstdwwtjdOjjoKiytYt+U4VdU1lg5LCLObP38+y5cv55NPPiExMZG5c+dSWlrKnDlzAJg9ezYLFiwAwM7Ojj59+jS4ubm54ezsTJ8+fbC1tUWlUvH444/zyiuvsHbtWhISEpg9ezYBAQGX9fMWtdWR13z2NvfNutHSoXR4trY2/N99NwPw2TfruFhw5doBlVXVxjZRbbmnG37Tq9tEM92nz3a8yuVNGT4gFG8PRyqqati48yR6g8Ek560vqLYlfr+0DxNNkqRbCCGuwtFBx41jI7HTacm9UMqGbSfQ600zWAthrWbNmsVbb73FwoUL6d+/P4cOHWL9+vXGQmipqalkZma26Jx/+9vfeOyxx3j44YcZMmQIJSUlrF+/Hjs7O3NcghDNNnFMND26daWsvIKVX/14xWPTz2ejKArOTg64uTq3UYS1vOtmunPzLpjkfGc6cBG139No1EwcEYGtjYbsvGL2HDbN/u6w4EAG9++NwaDw3Y/SPkw0TpJuIYRoBjcXe6aO6Y1WqyYju5DNu05L0RTR4T366KOcO3eOyspKdu/eTXR0tPGxuLg4Vq5c2eRzV65ceVn/bZVKxUsvvURWVhYVFRVs2rSJHj16mCl6IZpPrVYz7w+3A/DdT7+SkZnT5LGX9nP7NSh41xaMhdRMVL38Uruwjp90A7g42TEuujsAh09kcC7DNB9e3D6jrn3YemkfJhonSbcQQjSTj6czk0ZGoFarSErNY8eBZEm8hRCigxg6MJKhAyKpqdHz/qffNXncpf3cbVtEDcCnvpCaCfZ0V1RWkZpRu1qlI1Yub0pokCd9e9QWjft112mKS6+9SOrwIVH4+3pRVFzKL9I+TDRCkm4hhGiBIH9346fkR09lcuB4uoUjEkIIYSqP/OE2ADbG7ebE6ZRGj6nv0R3UxkXU4NLy8gsFRdTUXFt9kZTU8xgMCm4uTni6u5oivHbjuv4h+Hg6UVlVw8YdJ695y1iD9mFrpH2YuJwk3UII0ULdQ7wZMTAUgL1HUjmelGXhiIQQQphCz/BgJo27DoAlK75pNHky9uhu4yJqUNtCTqvVoCgKeRcKr+lc9f25u4UGtfkyeUvTaNTEDO+JrY2GnPwSdh8+d83nvPH6UdjpbElKTuNgwkkTRCk6Ekm6hRCiFfr2DGBA7y4AbNt3huQ0qVgqhBAdwcOzb8ZGq2XfoePsOXDsssfT6ma627pdGNTuPa/f151zjcXUjJXLO9HS8t9ycbJj/HW1K9eOnDxPcvq1jeMuzo5MmTACgG/WSvsw0ZAk3UII0UpD+3UlopsvigKbdp7kfM61zToIIYSwvAA/b26+cTxQO9tt+E1rqcLiEgqKSgDoEuBjkfhMVUztTErnqVzelJAunvTrGQDA5l2nKSq5tv3dt02vXWK+Nf4Amdl51xyf6Dgk6RZCiFZSqVSMHtyNkC4e6A0K67cmknex1NJhCSGEuEb333Ejjg72nD6b2qAwVnpdETVvT3cc7C3T6s7bBMXUFEUxznSHh3YxRVjtVnT/YHw9namq1l/z/u7Q4ECGDKhtH/b9T5tNGKVo7yTpFkKIa6BWq4gZ1gN/bxeqqvWsizt2zZ+UCyGEsCw3V2fuvX0qAO9/8h2VVdXAbyqXW2A/dz2fumJq17K8PDe/gKLiUjRqNSFdA00VWrukUauJGdETna2W3AslxB9Kuabz3TZ9IlDXPqyi0gQRio5Akm4hhLhGWq2GyaN74enmQFlFNT9uPkZ5hfTpFEKI9mzWjIl4ebqRlZPPdz/+CkBqem2LLUvs565Xv7w87xqWl5+pK6LWtYsfOlsbU4TVrjk76oz7u4+eyiQptfVLw4cP6UeAn7e0DxMNSNIthBAmoLPVMnVsJM6OOopKKvhx83HKK6stHZYQQohWsrPT8dA9MwFY+dUPFJeUGWe6g7q0fY/uet6ebsC1zXSfTpb93L8XHOhB/161s/6/xp8iLbN1y/d/2z7sa2kfJupI0i2EECbiaG/LDeMisbezIb+glB9ij8qMtxBCtGNTJ44kJCiAouJSPvvmJ9IyLFe5vF59r+5rKaRW3y4svJNWLm/K0H7BhHbxwFBXpyU9q6BV56lvH3YmJV3ahwlAkm4hhDApN2d7pk/og4O9DRcKy1gbe5TSckm8hRCiPdJqNDzyh1sBWLV6I+fS6peXW26m28errnp53sVWz6KeSU4HIDykcxdR+z21WkXM8J4EB7obC6RmZLe8M4mzkwNTY2rbh329ZqOpwxTtkCTdQghhYu4uDkyf0BdHB1suFpWzNjaBkjIppiKEEO3RyOj+REV2p6qqmqrqGjQaDf5+3haLx8vDDYDqmhoKCotb/PzKqmrjhweyvPxyGo2a60dE0DXAnRq9gZ+3HCezFS1B65eYb9t1UNqHCUm6hRDCHNyc7ZkxoS9OjjoKiytYG3uU4lKpai6EEO2NSqXikT/cZvw60N8brUZjsXhsbLS4u7kArVtinpJ6Hr3BgIuzI951s+aiIY1GzfUjI+ji50aN3sC6LcfJyi1q0TlCgwMZOiASg0ExFuITnZck3UIIYSYuTnbMmNAXFyc7ikoqWBN7VNqJCSFEO9Svd3fGDB8IQLAF24XVu5Ziakm/KaKmUqlMGVaHotWomTwqgkBfV6prDPwUd5zsvJatLLhtRgwAazdspbq6xhxhinZCkm4hhDAjZ0cd0yf0wdXZjpLSStbEJlBQXG7psIQQQrTQ/Ln3cMPEkdx3xzRLh2Ls1Z2b3/IK20lSubzZ6luC+vu4UF2j56e4Y+TkNz/xHja4H14ebhQVl7Ln4DEzRiqsnSTdQghhZk4OOqZP6Iu7iz2lZVWsjU3gYmGZpcMSQgjRAj5e7jw3/wEie4ZZOhRjr+7cvIIWPzepvohaqBRRaw4brYapo3vj5+1CVbWen+KOk3ehpFnP1WjUjB81BICN0rO7U5OkWwgh2oCjvS3TJ/TBw9WBsvJq1sYe5UJBqaXDEkII0Q7VVzBv6fJyRVFIOpsKyEx3S9jYaJg6phe+ns5UVtXw4+Zj5DdzDJ84JhqAbbsOUVEhRVU7K0m6hRCijdjb1SbeXu6OlFfWJt55F5v3abkQQghRr74AWl4Ll5fnXyykoKgEtVpFaHCgOULrsGxttEwd2xtvDycqqmr44ddjXGjGqrXIiDD8fb0oK69gx94jbRCpsEaSdAshRBuy09kwbXyfBoN2bjOXqQkhhBBwaXl5Tl7Lku76/dxBgX7Y6WxNHldHp7PVcuO4SLzcHamorOaHX49ysejKibdKpSJmzFAANm3Z3RZhCiskSbcQQrSx+kHb16t2mdoPvx5tcUVUIYQQnVf98vKWFlKT/dzXrn4M93RzpLyiNvG+WoHU68deB8DOPYcpLZViqp2RJN1CCGEBOlstN4ztjX9dYZYfNx8js4U9QIUQQnRO9TPdJaXllJU3vxXlpf3cXc0SV2dhp7PhxvGRxjotP8QepfAKiXe3kC6EBAVQVV3DlvgDbRipsBaSdAshhIXU7w8L8HE1tiLJyC60dFhCCCGsnKOjPQ72dkDLZrtlptt07HU2TBsfWduZpLyKH349RlFJ4x+AqFQqJo6tLagmS8w7J0m6hRDCgmy0GqaM6UUXPzdqagz8vOU46VkFlg5LCCGElasvppbbzH3d1dU1pKRlAlK53FTs7WyZNr4Pbs72lJRV8sOvRykubbxCeczo2n3dew4ep6BQtpR1NpJ0CyGEhdloNUwe3YuuAe7U6GsT79TzLdunJ4QQonNpaTG1lLTz6PV6nJ0c8PX2MGdonYqDvS3Txkfi4mRHcWlt4l1Sdnni3bWLHz3Dg9Hr9Wzesc8CkQpLkqRbCCGsgFajZtLICEK6eKA3KKzflkhKer6lwxJCCGGlWlpMrX5pebeQIFQqldni6owcHXRMn9AHFyc7ikoq+OHXo5Q2knjX9+zeGCdLzDsbSbqFEMJKaDRqJo7oSViQJwaDwi/bT3I2Lc/SYQkhhLBC9TPdzU+6a9uFyX5u83By0DFtfCROjjoKiyv4YfMxysqrGhwzoW6J+aGjp1rc7k20b5J0CyGEFdGo1cQM70l4sBcGRWHjjpMkncu1dFhCCCGsjE8L93Qnna1NuruHyX5uc3F2tGP6+D44OdhSUFTOD78epbziUuLt5+NJVGR3FEUhdtseC0Yq2pok3UIIYWXUahXjr+tBj1AfFAVi409xKjnH0mEJIYSwIi0tpJaUUpt0d5Miambl4mTHtPF9cLC35WJROT/8eozyymrj4zFj6quYS9LdmUjSLYQQVkitVjEuOpxe3XxRFNi8+zT5BaWWDksIIYSVaEkhtQsXC7lwsQiVSkVYcKC5Q+v0XJ3tmT6+Dw52NlwoLGNd3HH0egMA40cNQa1WcfzkWdLPywfqnYUk3UIIYaVUKhWjh3QjpIsHigLb951FURRLhyWEEMIK1C8vv1BQRE1NzRWPrS+iFhTgi72dzuyxCXBzsWfahD7obLXkXihhb0IqAB5uLgyO6g3Apq0y291ZSNIthBBWTKVSMWJgGFqNmszcIpLOSWE1IYQQ4ObqjFarQVEU8i8WXvHY+iJq3aSIWptyd3Fg7NBwAA4lZnA+p/Z9mji2ror5ll0Wi020LUm6hRDCyjk76hgYWfuHUvzBZKqqrzyjIYQQouNTq9V4ebgBV19ifqlyueznbmuhQZ5EhPkA8Gv8KSqrahgzfBBarYazKRmcSUm3cISiLUjSLYQQ7UBURCCuznaUVVSzLyHN0uEIIYSwAs0tplafdEvlcssYMTAMFyc7Ssqq2LbvDM5ODgwb3BeQJeadhSTdQgjRDmg0akYOCgMg4dR5LhSWWTgiIYQQltacXt01NTUkp54HZKbbUmxsNEwY1gOVCpLO5XE6JZeJY64DYGPcbqnX0glI0i2EEO1EkL87ocaiamdkkBZCiE6uvpjalZaXn0vPoqZGj6ODPX4+nm0VmvgdXy9nBkXWfuixbd8ZovpGYKezJSMzhxOnUywbnDA7SbqFEKIdGT4wFK1GzfkcKaomhBCdXXNmupPO1u/n7oJKpWqTuETjBkYG4evpTFW1nvhDqYyM7g/Axi27LRuYMDtJuoUQoh1xdrRjQH1RtUMpUlRNmNWSJUsICQnBzs6O6Oho9uxpeu/hd999x+DBg3Fzc8PR0ZH+/fvz2WefNTjm/vvvR6VSNbhNnjzZ3JchRIfl04w93Zcql8vScktTq1WMH9YdrVZNZk4R3brVVjbftGUPBoPBwtEJc5KkWwgh2pn+EYG4ONlRVl7F/qNSVE2Yx6pVq5g/fz6LFi3iwIEDREVFMWnSJHJycho93sPDg2effZb4+HiOHDnCnDlzmDNnDhs2bGhw3OTJk8nMzDTevvzyy7a4HCE6JONM9xWS7tP1RdQk6bYKrs72jBxYW6OlvMYORwd7cvMvcvjYaQtHJsxJkm4hhGhnGhRVO5kpRdWEWbz99ts89NBDzJkzh969e7Ns2TIcHBxYsWJFo8ePHTuWm266iV69etGtWzf+/Oc/069fP7Zv397gOJ1Oh5+fn/Hm7u7eFpcjRIdkrF6ef7HJOh9nkmtbUkkRNevRM8yH0C6eqFRqgoNDANgkS8w7NEm6hRCiHeoa4E5IoAcGRWH7vrNSVE2YVFVVFfv37ycmJsZ4n1qtJiYmhvj4+Ks+X1EUYmNjOXnyJKNHj27wWFxcHD4+PvTs2ZO5c+eSn5/f5HkqKyspKipqcBNCXFLfp7uquobCopLLHr9YUETehQJUKhVhIYFtHJ1oikqlYszQbjjY2xAYGAzAr9v2UlMjW8Y6Kkm6hRCinRo+MBSNRs35nELOpEpRNWE6eXl56PV6fH19G9zv6+tLVlZWk88rLCzEyckJW1tbbrjhBt577z0mTpxofHzy5Ml8+umnxMbG8vrrr7NlyxamTJmCXq9v9HyLFy/G1dXVeAsKkpk6IX7L1tYGd1dnoPFiakl1s9yB/t442Nu1aWziyux0NoyL7o6fXwB2dnYUFJWw73CipcMSZiJJtxBCtFMuTnYM7F1XVO1gCtXVjScuQrQVZ2dnDh06xN69e3n11VeZP38+cXFxxsfvuOMOpk+fTt++fZk5cyY//vgje/fubXDMby1YsIDCwkLjLS1NahgI8XveV2gblpRSX7lcPrCyRkH+7kRFBBIcHArA+tirryQS7ZMk3UII0Y5F9aotqlZaXsX+Y5KQCNPw8vJCo9GQnZ3d4P7s7Gz8/PyafJ5arSY8PJz+/fvzxBNPcOutt7J48eImjw8LC8PLy4ukpKRGH9fpdLi4uDS4CSEaulIxtUv7ubu0aUyi+aKjgunXJxKAuJ37qaissnBEwhwk6RZCiHZMq1EzYmDtJ+RHTpznohRVEyZga2vLoEGDiI2NNd5nMBiIjY1l2LBhzT6PwWCgsrKyycfT09PJz8/H39//muIVojP7bTG13zt9NhWA8NCubRqTaD6tVsM9N43GwcGRysoqvv1xm6VDEmYgSbcQQrRzwYEeBAe61xZV2y9F1YRpzJ8/n+XLl/PJJ5+QmJjI3LlzKS0tZc6cOQDMnj2bBQsWGI9fvHgxGzdu5OzZsyQmJvKPf/yDzz77jHvuuQeAkpIS/vrXv7Jr1y5SUlKIjY1lxowZhIeHM2nSJItcoxAdgU8Ty8tr9HqSz50HZKbb2vl4OjNi6AAA1m3aSUFRuYUjEqamtXQAQgghrt2IgWGkZx0kI7uQs2n5dOvqZemQRDs3a9YscnNzWbhwIVlZWfTv35/169cbi6ulpqaiVl/67L60tJRHHnmE9PR07O3tiYiI4PPPP2fWrFkAaDQajhw5wieffEJBQQEBAQFcf/31vPzyy+h0OotcoxAdgXF5+e9mutPSs6iuqcHB3g5/XxkTrN2dN41nY9x2UtPO8fOWo9x+wyA0apkf7Sgk6RZCiA7AxcmOAb0C2Xc0jZ0Hk+nq746NjcbSYYl27tFHH+XRRx9t9LHfFz975ZVXeOWVV5o8l729PRs2bDBleEIIwMfLA7h8T/fp5No6H91CuzT4gExYp4juIQT6+5CRmcPBI8fpFuzD0H7Blg5LmIj8BgohRAfRv1cgzo46SsukqJoQQnQW3p5uwOUz3Ul1SXd4iFQubw9UKhXXj70OgOSUsxw8nk5mbpGFoxKmIkm3EEJ0EFqthhGDwgA4cvI8BUVSVE0IITq6+kJqxSVllFdcKlwolcvbn4ljhgKQeT6diooKfo0/RVV1jYWjEqYgSbcQQnQgIYEeBAe4YzAobN+fLEXVhBCig3N0sMfB3g5ouMT89Nm6me4wmeluL0KDAwkPDUJvMJCTnUFxaSXb9ydbOixhApJ0CyFEBzNiUBgatYr0rAKS0/MtHY4QQggzUqlUeP1uiXlhUYnx/7sFy0x3exJTN9udl5OBSgWnknM4k5pn4ajEtZKkWwghOhgXJzv69679I2vngWSqa/QWjkgIIYQ51RdTq28bdialdml5gJ83jo72FotLtNzEMdEAHD1xmm5BrgBs3XuGkrLKKz1NWDlJuoUQogMaUFdUraSsigPH0i0djhBCCDP6fTG102dTAQgPlaXl7U2AnzeRPcMwGBTyczPx9nCisqqGzbtOy5axdsziSfeSJUsICQnBzs6O6Oho9uzZc8XjCwoKmDdvHv7+/uh0Onr06MG6devaKFohhGgftFoNIwaGAnD4RAYFReUWjkgIIYS51BdTq9/TnSRF1Nq1iWNrZ7tjt+1hwrAeaDVqMrILOXLyvIUj6xi+WbuJnNwLbfqaFk26V61axfz581m0aBEHDhwgKiqKSZMmkZOT0+jxVVVVTJw4kZSUFL799ltOnjzJ8uXLCQwMbOPIhRDC+gUHetDVWFTtrHxCLoQQHdRly8vr24XJTHe7NH7UEFQqFQnHkygvL2V43Yfouw+fI/9iqYWja98SEpN4e+kX3PHwMxSXtF2XF4sm3W+//TYPPfQQc+bMoXfv3ixbtgwHBwdWrFjR6PErVqzgwoULrF69mhEjRhASEsKYMWOIiopq48iFEML6qVQqRgwMRW0sqta2n+oKIYRoG79dXl6j13PmXAYglcvbK29Pdwb26wlA7NY99OrmS3Bg7YfosfGnqNEbLBxh+/XRF2sAmDB6KM5ODm32uhZLuquqqti/fz8xMTGXglGriYmJIT4+vtHnrF27lmHDhjFv3jx8fX3p06cPr732Gnp900WCKisrKSoqanATQojOwtXZnv69alcDSVE1IYTomOpnunPzLpJ+PoeqqmrsdLYE+nlbODLRWjGja5eYb9yyG5VKxdih4djrbLhQWMbuwymWDa6dSkhMYvf+o2jUau6/48Y2fW2LJd15eXno9Xp8fX0b3O/r60tWVlajzzl79izffvster2edevW8fzzz/OPf/yDV155pcnXWbx4Ma6ursZbUJB84ieE6FwG9O6Ck6OOkrJKDh6XompCCNHReHvW7um+UFDIyaQUALqFdEGttnj5JtFK40YORqPRcOpMKufSM7G3s2XsdeEAJJzMlDZirVA/yz0lZgSB/j5t+trt6jfRYDDg4+PDBx98wKBBg5g1axbPPvssy5Yta/I5CxYsoLCw0HhLS0trw4iFEMLybH5TVO1QYgYFxVJUTQghOhJ3N2c0Gg0Gg8Lu/UcBWVre3rm6OBE9MBKATVt2AxAc4EFURAAAm3edJie/2GLxtTeWnOUGCybdXl5eaDQasrOzG9yfnZ2Nn59fo8/x9/enR48eaDQa4329evUiKyuLqqqqRp+j0+lwcXFpcBNCiM4mJNCDIH83DAaFHVJUTQghOhS1Wm3c171rXwIgRdQ6gpi6nt2/xO02jtvRUSF0DXCnRm9g/bYT0r+7mSw5yw0WTLptbW0ZNGgQsbGxxvsMBgOxsbEMGzas0eeMGDGCpKQkDIZLxQNOnTqFv78/tra2Zo9ZCCHaK5VKxYhBYajVKtIyC0jJkKJqQgjRkXjVJd0XC2tnPyXpbv9GXzcAW1sbUtOzOH22drWuWq0iZngP3F0dKCuvYsO2RKnXchWWnuUGCy8vnz9/PsuXL+eTTz4hMTGRuXPnUlpaypw5cwCYPXs2CxYsMB4/d+5cLly4wJ///GdOnTrFTz/9xGuvvca8efMsdQlCCNFuuDnbExVRW1RthxRVE0KIDqW+mFo96dHd/jk62jNiSG2Xpo1xu4z329pomTK6F3Y6LbkXStm867SsYLsCS89yg4WT7lmzZvHWW2+xcOFC+vfvz6FDh1i/fr2xuFpqaiqZmZnG44OCgtiwYQN79+6lX79+/OlPf+LPf/4zTz/9tKUuQQgh2pWBkV1wctBRUlpJ3O4kGaSFEKKDqC+mBuDn44mTY9u1QxLmM3Fs7RLzTVv3NBizXZzsmDQyArVaxdm0fPYdlbpVjbGGWW4ArcVeuc6jjz7Ko48+2uhjcXFxl903bNgwdu3adfnBQgghrspGq2HC8B78EHuUM6l5eHs4GVuKCSGEaL/q93QDdJciah3GsCH9cLC3Iysnn4TEJPr17m58zN/HldFDuhG3O4n9R9Nwd7EnPFjaxP2WNcxyQzurXi6EEOLa+Xu7MLyumvnuwymkZRZYNiAhhBDX7LfLy7vJfu4Ow05ny+jhAwHYtGXPZY9HhPkat45t3p1EtlQ0N7KWWW6QpFsIITqlyO5+9Az1QVFg086TFJVUWDokIYQQ18Db69Lycimi1rFMHD0UgNhte6jRX16PJToqmOBAd/R6Axu2JkpF8zrWMssNknQLIUSnpFKpGDWkG94eTlRW1bBh2wkprCaEEO2Yz2+S7u6SdHcoQwdG4uLsyIWLRRw8cvKyx9VqFROG9cDD1YGyimrWb5WK5tY0yw2SdAshRKel1aiZNDICe50N+QWlbNkjhdWEEKK98vFyx9/Xi6BAX4vP6gnT0mq1jBs5GIBNW3c3eoytjZbJo3thp7Mh72Ipv8Z37orm1jTLDZJ0CyFEp+bkqGPiyJ6oVSqSzuVx5OR5S4ckhBCiFbRaLf99/1U+/8/LaDTyJ35HM3FMbRXzzdv3U11d0+gxLk52TBpVW9E8OT2fvQmpbRmi1bC2WW6QpFsIITq9AB9Xhg0MAWDXoRQysgosGo8QQojWsdPZYmtrY+kwhBn079MTLw83iktK2X3gaJPH+Xu7MGZoOAAHjqVzKiWnrUK0GtY2yw2SdAshhAD6dPenR11htY07pLCaEEIIYU00GjXjRw0BYGNc40vM6/UM9WFAXTvQLbuTyM7rPBXNrXGWG6ygT7cQQgjLU6lUjB4cxsXCUnIvlLJh2wlmTuyLjVZj6dCEEEIIAVw/Npqv12wkduseEk8n4+rihLurM64uznX/dcLN1bn25uKEq4OavMIKft56nFsm9cfZUWfpSzA7a5zlBkm6hRBC1NFqNVw/shf/23CY/IJStu45w/hh3VGpVJYOTQghhOj0evcMI6J7CCdOp5CWkU1aRnaznqdWq/nivw74+bjj7uaMm0ttYl6ftHcJ9GVI/97tfry31llukKRbCCHEbzg76pg4oic/bj7K6XO5eHs40S8iwNJhCSGEEJ2eSqVi+dvPkp6ZS2FhMRcLiykoLKagqISCwmIKi2rvK6z7uqCwmIrKKgwGAyWlJSQllzR57nEjB/PsX/6Ao4N9G16RaVnrLDdI0i2EEOJ3An1dGTYglJ0Hkok/lIynuwOBvm6WDksIIYTo9LRaLSFB/hDk36zjKyoqOZ2SyY+xhykrr8DP0x5PN7u6ZL2YiwVF7Nx7hM3b93H2XAaLn51HaHCgma/C9Kx5lhsk6RZCCNGIvj38yb1QwumUXDbuOMktk6JwdrSzdFhCCCGEaAE7Ox19I0LQ2Tnwa/xpAAb0707P0EszwUcTz/Dsa0s4l5bJA4+/zDOPzyGmrkVZe2HNs9wg1cuFEEI0QqVSMWZIN7zcHamorGHDthPU1OgtHZYQQgghWqFHiA8DencBYMueJLJyi4yP9enVjZXvvcCgqF6UV1Ty/N+X8c9l/22yH7i1sfZZbpCkWwghRBO0Wg2TRkVgZ6sl72IpW/eeQVEUS4clhBBCiFYY2q8roV08MBgU1m87QXHppfag7m4u/OvVJ5k96wYAvl6zkXlPv05O3kVLhdts1j7LDZJ0CyGEuAJnRzsmjuiJSgWnUnI5eirT0iEJIYQQohVUKhXjh/XA082Rispqft6SSNVvZrM1GjVz77+V1xc+hpOjPQnHk7j/sRc4cOSEBaO+svYwyw2SdAshhLiKQD83rusfAsDOg8mczym0bEBCCCGEaBUbrYYpo3vhYGfDhcIyYneewmBouIpt9LCBrHh3EeGhQVwsKOJPC97k829/tsrVbu1hlhsk6RZCCNEM/XoGEB7shaLAL9tPUlJaaemQhBBCCNEKTo46Jo3uhUaj5tz5i+w+fO6yY4ICfFn+9rNMnjAcvcHAko++ZsEr/6aktMwCETeuvcxygyTdQgghmkGlUjFmaLhxSdqG7VJYTQghhGivfD2dGTs0HIDDJzI4eDz9smPs7HQsfOJB/vrobGy0WrbsPMAf/vwSZ1IuP9YS2sssN0jSLYQQopls6gqr6Wy15F4oYeu+s1a51EyYzpIlSwgJCcHOzo7o6Gj27NnT5LHfffcdgwcPxs3NDUdHR/r3789nn33W4BhFUVi4cCH+/v7Y29sTExPD6dOnzX0ZQgghGtE9xJsh/boCsPvwOfYcOXfZuK5Sqbj5hnEsfWsBvt4epGVk8+DjL7Ph13hLhGzUnma5QZJuIYQQLeDi9JvCask5HDudZemQhJmsWrWK+fPns2jRIg4cOEBUVBSTJk0iJyen0eM9PDx49tlniY+P58iRI8yZM4c5c+awYcMG4zFvvPEG7777LsuWLWP37t04OjoyadIkKioqGj2nEEII8xoUGUR0VDAAB46ls/NgcqMfqEf2DGPley8wdEAkFZVVvPDmB/zjP59brK1Ye5rlBlApnWyaoqioCFdXVwoLC3FxcbF0OEII0S4dSsxg16EU1CoVN46PJMDH1dIhtVvWOi5FR0czZMgQ/v3vfwNgMBgICgriscce4+mnn27WOQYOHMgNN9zAyy+/jKIoBAQE8MQTT/Dkk08CUFhYiK+vLytXruSOO+646vms9XslhBDt3dHTmWzfdxaAiG6+jB7cDbVaddlxer2BD79YzcovfwCgT0Q3Xn3mEXy8Pdos1oTEJB6e/yoatZpVHy62aNLd3HFJZrqFEEK0WFREAOFdvTAoChu3n6SkTAqrdSRVVVXs37+fmJgY431qtZqYmBji46++pFBRFGJjYzl58iSjR48GIDk5maysrAbndHV1JTo6ulnnFEIIYT59uvszLro7KhWcOJPNr7tOoTcYLjtOo1Hzf7Nv5q0XH8fZyYGjJ85w36OL2HvweJvF2t5muUGSbiGEEK2gUqkYEx2Op5sD5ZXVbNh2gmoprNZh5OXlodfr8fX1bXC/r68vWVlNbykoLCzEyckJW1tbbrjhBt577z0mTpwIYHxeS85ZWVlJUVFRg5sQQgjz6BnmQ8zwnqhVKpLO5bFx+0n0+ssTb4ARQ6P4+N1FdA/rSkFRCY8/9xafrPoRQyOJuim1t73c9STpFkII0Sq1hdV6GQur/W/9YTJzJSnqzJydnTl06BB79+7l1VdfZf78+cTFxbX6fIsXL8bV1dV4CwoKMl2wQgghLtOtqxeTRkWgUatIybjAz1sTm/xQPdDfhw/efpYbJo7EYFBYtvJ/PP3yexSXmK+tWHuc5QZJuoUQQlwDFyc7Jo+KwMHehoLictZsSmDH/rMy693OeXl5odFoyM7ObnB/dnY2fn5+TT5PrVYTHh5O//79eeKJJ7j11ltZvHgxgPF5LTnnggULKCwsNN7S0tKu5bKEEEI0Q3CgB1PH9EarVZOeVcC6uONUNVEwzU5ny7N/+QNP/+l+bLRatu06xJw/vcg3azeRfr7xwput1V5nuUGSbiGEENfI38eVWVMH0jO09hPnhFOZfL3uIBlZBZYNTLSara0tgwYNIjY21nifwWAgNjaWYcOGNfs8BoOBysra/f6hoaH4+fk1OGdRURG7d+9u8pw6nQ4XF5cGNyGEEOYX6OfGjWMjsbXRkJlbxA+/HqOisrrRY1UqFTOmjOH9fzyDn48nGZk5vL30C2574Cluf/Bp/rnsC+L3JVBRWXVNMbXXWW4AraUDEEII0f7pbLWMu6474cFebNmTRHFpJT9sPkbvcF+u6x+CrY0MN+3N/Pnzue+++xg8eDBDhw7lnXfeobS0lDlz5gAwe/ZsAgMDjTPZixcvZvDgwXTr1o3KykrWrVvHZ599xtKlS4HaP8oef/xxXnnlFbp3705oaCjPP/88AQEBzJw501KXKYQQogl+3i5MG9+HnzYfI/dCCWtjj3LjuEgc7G0bPb5Xj1BW/vsFfli/lZ17j3DkeBJpGdmkZWTz9ZpN2NraMLBfBMMG92XY4L4EBTa9cur32vMsN0jSLYQQwoSC/N25feoAdh06x/GkLI4nZZN6/iKjh4TTNcDd0uGJFpg1axa5ubksXLiQrKws+vfvz/r1642F0FJTU1GrLy2YKy0t5ZFHHiE9PR17e3siIiL4/PPPmTVrlvGYv/3tb5SWlvLwww9TUFDAyJEjWb9+PXZ2dm1+fUIIIa7O28OJ6TF9+XHzUS4UlrEmNoFp4/rg5Khr9HhXZyfuuW0q99w2ldLScvYeOkb8vgTi9yaQm3+RXfsS2LUvgX9Suye8PgEf2C8CO7vGzwnte5YbpE+3pcMRQogOKyO7gC17zlBUUgFAz1Afhg8MRWcrn/f+loxLzSffKyGEsIzC4nJ+2HyMktJKnBx1TBsXiauzfbOfrygKZ89lEL8vgV37jnD42GlqflP/xdZGy4B+EVw3qC/DhvSla6AfKlVtn3Br6sv9e80dlyTpFkIIYTbVNXr2HDlHwslMABzsbBg1pBuhXTwtHJn1kHGp+eR7JYQQllNSWskPm49SWFyBg70NN47rg4erQ6vOVVpWzr5DicTvO8KufQlk515o8HiAnzfX1c2Cf71mI3sPHufG60fx7F/+YIpLMRlJupsgA7YQQrS9rNwi4nYnUVBcDkB4Vy9GDArD3s7GwpFZnoxLzSffKyGEsKyy8ip+3HyMC4Vl2Om03DA2Em8Pp2s6p6IopKSer12Gvi+BQ0dPNpgFB6xylhsk6W6SDNhCCGEZNXoD+xNSOXQiA0UBO52WkYPC6NbVy7iErDOScan55HslhBCWV1FZzU9xx8m9UIKtjYapY3rj5226f5PLyivYfziR+L0JxO87QlZOPrfPiOEvf7zbZK9hKpJ0N0EGbCGEsKyc/GLididxobAMgNAuHowc3A3HJqqhdnQyLjWffK+EEMI6VFXX8POWRDJzi9Bq1UwZ1YtAPzeTv46iKFwsLMbNxalB8U5r0dxxyfoiF0II0aH5eDpzy6QoBvUJQq1SkZx+ga/XHeRkcg6d7HNgIYQQol2ytdEydWxvuvi5UVNjYN2W45zLuHD1J7aQSqXCw83FKhPulmjf0QshhGiXNBo1Q/p25ZZJUXi5O1JZVcPmXadZtyWRktJKS4cnhBBCiKuw0WqYMroXIYEe6A0KG7ad4ExqnqXDskqSdAshhLAYT3dHbr4+iuioYDRqFWmZF1m17iDHk7Jk1lsIIYSwchqNmokjexIe7IVBUdi08yQnzmZbOiyrI0m3EEIIi1KrVQzo3YVbJ/fH18uZ6ho9W/ee4eufD3HiTDY1eoOlQxRCCCFEEzRqNeOv60FEN18UBeJ2J7HjwFmqqmssHZrVkKRbCCGEVXB3dWDGhL4MHxCKjVbNxcIy4vYk8cWafew7mkp5RbWlQxRCCCFEI9RqFWOGdKNfzwAAEk5m8tVPB0g6lysr15Dq5ZYORwghRCMqq2pIPJNNwqnzlJZVAbVL2HqEeNMvIgB3FwcLR2g6Mi41n3yvhBDC+qVlXmTbvrMUlVQAEOjrysjBYR1q7K4nLcOaIAO2EEK0H3qDgbOp+Rw5mUHuhVLj/V0D3InqGUCAr2u77/Et41LzyfdKCCHahxq9gcOJGRw4no5eb0CtVhEVEcjAyC7YaDWWDs9kmjsuadswJiGEEKJFNGo13UO8CQ/2Iiu3iMMnzpOScYHU8xdJPX8RTzdHoiIC6NbVC41GdkwJIYQQ1kCrUTOoTxDdQ7zZvv8sqecvcvB4OqdTchkxKJSQQI92/6F5S8hMtxBCiHaloLichJPnOXk2x1hkzcHelr49/OnVzRc7nY2FI2wZGZeaT75XQgjR/iiKQkrGBXYcSDa2Be0a4M7IQWG4ONlZOLprI8vLmyADthBCdAwVldUcT8rm6OnzlJXXFlnTatT0DPOhX88AXJ3tLRxh88i41HzyvRJCiParukbPgWPpHD6RgcGgoNGoGdA7kP69uqBtp6vVJOluggzYQgjRsej1BpJS8zhyIoP8gjLj/SFdPIjqGYCft4tVL2GTcan55HslhBDt38WiMrbvO0tGdiEALk52jBwURtcAdwtH1nKSdDdBBmwhhOiYFEUhI7uQIyfPk3r+ovF+bw8noiICCA3yRKO2vk/SZVxqPvleCSFEx6AoCmdS89h5MNm4Wi0syJPhA0JxctRZOLrmk0JqQgghOhWVSkUXPze6+LlxobCMhJPnOZWcQ+6FEjbtPIWNVk2Aj6vxGDcXe6ueARdCCCE6KpVKRXiwN10D3NmXkEbCqfOcTcsnNfMig/sE0bdngFV+UN5aMtMthBCiwyqvqOLY6SyOJWVRXlHd4DFHe1sC/dzo4udKF183HOxtLRKjjEvNJ98rIYTomPIvlrJt3xmy8ooBcHexZ9SQbgT4uFo4siuT5eVNkAFbCCE6H0VRyLtYSnpWAelZBWTlFqE3NBz+PN0c6OLnRqCvG/4+Lm3WR1TGpeaT75UQQnRciqJwMjmHXYfOUVFZ+0F59xBvhvUPsdgH41cjSXcTZMAWQghRU6MnM7eY9KwCMrILyLtY2uBxtVqFn5dL3VJ0V7zcnVCrzbMUXcal5pPvlRBCdHyVVTXsPnyO40lZANjaaAjwccXB3hZHe1scHWr/W/+1zlZrse1isqdbCCGEaIJWqyHI340gfzcAyiuqycguMM6El5RVcT6nkPM5hew5AjpbLYG+l/aDt/e+okIIIYS10tlqGT2kGxFhPmzbd5bcCyWkZFxo8niNWmVMwH+bmBv/v+5+WxvLpb6SdAshhOj07O1sCA/2JjzYG0VRKCyuMCbg53MKqayq4WxaPmfT8oHa9iZd/FwZ0i8Ye52NhaMXQgghOh4fT2dumtiPjOwCikoqKCuvorTuVv//FZU16A0KxaWVFJdWXvF8NlqNMQF3cbZj7NDwNroSSbqFEEKIBlQqFW4u9ri52NOnhz8Gg0LOheK6JLyQnLxiikoqOJVcxYiBYZYOVwghhOiw1GoVQf5N9+/W6w0NkvDf/n9ZeRWlZbX/X12jp7pGT0FxOQXF5ZSUXTlBNzVJuoUQQogrqN/f7eflwuA+UFVdQ2ZOEcVllWg0HaediRBCCNHeaDRqXJzsrrrtq6q6hrLy6rrEvBIVbbsHXJJuIYQQogVsbbQEB3pYOgwhhBBCNJOtjRZbGy1uLvYWeX35iF4IIYQQQgghhDATSbqFEEIIIYQQQggzkaRbCCGEEEIIIYQwE0m6hRBCCCGEEEIIM5GkWwghhBBCCCGEMBNJuoUQQgghhBBCCDORpFsIIYQQQgghhDATSbqFEEIIIYQQQggzkaRbCCGEEEIIIYQwE0m6hRBCCCGEEEIIM5GkWwghhBCNWrJkCSEhIdjZ2REdHc2ePXuaPHb58uWMGjUKd3d33N3diYmJuez4+++/H5VK1eA2efJkc1+GEEIIYVGSdAshhBDiMqtWrWL+/PksWrSIAwcOEBUVxaRJk8jJyWn0+Li4OO688042b95MfHw8QUFBXH/99WRkZDQ4bvLkyWRmZhpvX375ZVtcjhBCCGExknQLIYQQ4jJvv/02Dz30EHPmzKF3794sW7YMBwcHVqxY0ejxX3zxBY888gj9+/cnIiKCDz/8EIPBQGxsbIPjdDodfn5+xpu7u3tbXI4QQghhMZJ0CyGEEKKBqqoq9u/fT0xMjPE+tVpNTEwM8fHxzTpHWVkZ1dXVeHh4NLg/Li4OHx8fevbsydy5c8nPzzdp7EIIIYS10Vo6ACGEEEJYl7y8PPR6Pb6+vg3u9/X15cSJE806x1NPPUVAQECDxH3y5MncfPPNhIaGcubMGZ555hmmTJlCfHw8Go3msnNUVlZSWVlp/LqoqKiVVySEEEJYTqdLuhVFAWTgFkIIYR3qx6P68akj+Pvf/85XX31FXFwcdnZ2xvvvuOMO4//37duXfv360a1bN+Li4pgwYcJl51m8eDEvvvjiZffLGC6EEMIaNHcM73RJd3FxMQBBQUEWjkQIIYS4pLi4GFdXV0uHAYCXlxcajYbs7OwG92dnZ+Pn53fF57711lv8/e9/Z9OmTfTr1++Kx4aFheHl5UVSUlKjSfeCBQuYP3++8euMjAx69+4tY7gQQgircrUxvNMl3QEBAaSlpeHs7IxKpbqmcxUVFREUFERaWhouLi4mitAyOsq1dJTrgI5zLR3lOqDjXEtHuQ7oGNeiKArFxcUEBARYOhQjW1tbBg0aRGxsLDNnzgQwFkV79NFHm3zeG2+8wauvvsqGDRsYPHjwVV8nPT2d/Px8/P39G31cp9Oh0+mMXzs5OckY3oiOci0d5Tqg41xLR7kO6DjX0lGuAzrGtTR3DO90SbdaraZLly4mPaeLi0u7/UH5vY5yLR3lOqDjXEtHuQ7oONfSUa4D2v+1WMsM92/Nnz+f++67j8GDBzN06FDeeecdSktLmTNnDgCzZ88mMDCQxYsXA/D666+zcOFC/vvf/xISEkJWVhZQmyg7OTlRUlLCiy++yC233IKfnx9nzpzhb3/7G+Hh4UyaNKlZMckYfmUd5Vo6ynVAx7mWjnId0HGupaNcB7T/a2nOGN7pkm4hhBBCXN2sWbPIzc1l4cKFZGVl0b9/f9avX28srpaamopafakJytKlS6mqquLWW29tcJ5FixbxwgsvoNFoOHLkCJ988gkFBQUEBARw/fXX8/LLLzeYzRZCCCE6Gkm6hRBCCNGoRx99tMnl5HFxcQ2+TklJueK57O3t2bBhg4kiE0IIIdoP6dN9DXQ6HYsWLeoQn9B3lGvpKNcBHedaOsp1QMe5lo5yHdCxrkW0rY70s9NRrqWjXAd0nGvpKNcBHedaOsp1QMe6lqtRKR2pR4kQQgghhBBCCGFFZKZbCCGEEEIIIYQwE0m6hRBCCCGEEEIIM5GkWwghhBBCCCGEMBNJuq9iyZIlhISEYGdnR3R0NHv27Lni8d988w0RERHY2dnRt29f1q1b10aRNm3x4sUMGTIEZ2dnfHx8mDlzJidPnrzic1auXIlKpWpws7Oza6OIG/fCCy9cFlNERMQVn2ON7wdASEjIZdeiUqmYN29eo8dby/uxdetWpk2bRkBAACqVitWrVzd4XFEUFi5ciL+/P/b29sTExHD69Omrnrelv2emcKVrqa6u5qmnnqJv3744OjoSEBDA7NmzOX/+/BXP2ZqfUXNeB8D9999/WUyTJ0++6nmt7T0BGv2dUalUvPnmm02e0xLvibAeMobLGG4OMoY3ZG3jhYzh1veegIzhknRfwapVq5g/fz6LFi3iwIEDREVFMWnSJHJycho9fufOndx555088MADHDx4kJkzZzJz5kyOHj3axpE3tGXLFubNm8euXbvYuHEj1dXVXH/99ZSWll7xeS4uLmRmZhpv586da6OImxYZGdkgpu3btzd5rLW+HwB79+5tcB0bN24E4LbbbmvyOdbwfpSWlhIVFcWSJUsaffyNN97g3XffZdmyZezevRtHR0cmTZpERUVFk+ds6e+ZqVzpWsrKyjhw4ADPP/88Bw4c4LvvvuPkyZNMnz79qudtyc+oKVztPQGYPHlyg5i+/PLLK57TGt8ToME1ZGZmsmLFClQqFbfccssVz9vW74mwDjKGW37M+D0Zw2UMNxUZw5tmje8JyBiOIpo0dOhQZd68ecav9Xq9EhAQoCxevLjR42+//XblhhtuaHBfdHS08n//939mjbOlcnJyFEDZsmVLk8d8/PHHiqura9sF1QyLFi1SoqKimn18e3k/FEVR/vznPyvdunVTDAZDo49b4/sBKN9//73xa4PBoPj5+Slvvvmm8b6CggJFp9MpX375ZZPnaenvmTn8/loas2fPHgVQzp071+QxLf0ZNbXGruO+++5TZsyY0aLztJf3ZMaMGcr48eOveIyl3xNhOTKGu7ZdUM0gY7hr2wZ1FTKGX87S44WM4Zez9HtiSjLT3YSqqir2799PTEyM8T61Wk1MTAzx8fGNPic+Pr7B8QCTJk1q8nhLKSwsBMDDw+OKx5WUlBAcHExQUBAzZszg2LFjbRHeFZ0+fZqAgADCwsK4++67SU1NbfLY9vJ+VFVV8fnnn/OHP/wBlUrV5HHW+H78VnJyMllZWQ2+566urkRHRzf5PW/N75mlFBYWolKpcHNzu+JxLfkZbStxcXH4+PjQs2dP5s6dS35+fpPHtpf3JDs7m59++okHHnjgqsda43sizEvGcOscM2QMt67347dkDK9ljeOFjOHW9560hiTdTcjLy0Ov1+Pr69vgfl9fX7Kyshp9TlZWVouOtwSDwcDjjz/OiBEj6NOnT5PH9ezZkxUrVrBmzRo+//xzDAYDw4cPJz09vQ2jbSg6OpqVK1eyfv16li5dSnJyMqNGjaK4uLjR49vD+wGwevVqCgoKuP/++5s8xhrfj9+r/7625Hvemt8zS6ioqOCpp57izjvvxMXFpcnjWvoz2hYmT57Mp59+SmxsLK+//jpbtmxhypQp6PX6Ro9vL+/JJxhm7/0AAAoKSURBVJ98grOzMzfffPMVj7PG90SYn4zh1jdmyBhuXe/H78kYbp3jhYzh1veetJbW0gGItjVv3jyOHj161f0Qw4YNY9iwYcavhw8fTq9evXj//fd5+eWXzR1mo6ZMmWL8/379+hEdHU1wcDBff/11sz4ps1YfffQRU6ZMISAgoMljrPH96Cyqq6u5/fbbURSFpUuXXvFYa/wZveOOO4z/37dvX/r160e3bt2Ii4tjwoQJFonJFFasWMHdd9991WJE1vieCNFaMoZbHxnDrZuM4dapM47hMtPdBC8vLzQaDdnZ2Q3uz87Oxs/Pr9Hn+Pn5tej4tvboo4/y448/snnzZrp06dKi59rY2DBgwACSkpLMFF3Lubm50aNHjyZjsvb3A+DcuXNs2rSJBx98sEXPs8b3o/772pLveWt+z9pS/WB97tw5Nm7ceMVPyBtztZ9RSwgLC8PLy6vJmKz9PQHYtm0bJ0+ebPHvDVjneyJMT8bwhqxxzJAx3LreDxnDL2eN44WM4db3njSXJN1NsLW1ZdCgQcTGxhrvMxgMxMbGNvi08reGDRvW4HiAjRs3Nnl8W1EUhUcffZTvv/+eX3/9ldDQ0BafQ6/Xk5CQgL+/vxkibJ2SkhLOnDnTZEzW+n781scff4yPjw833HBDi55nje9HaGgofn5+Db7nRUVF7N69u8nveWt+z9pK/WB9+vRpNm3ahKenZ4vPcbWfUUtIT08nPz+/yZis+T2p99FHHzFo0CCioqJa/FxrfE+E6ckY3pA1jhkyhlvX+yFj+OWscbyQMdz63pNms2wdN+v21VdfKTqdTlm5cqVy/Phx5eGHH1bc3NyUrKwsRVEU5d5771Wefvpp4/E7duxQtFqt8tZbbymJiYnKokWLFBsbGyUhIcFSl6AoiqLMnTtXcXV1VeLi4pTMzEzjrayszHjM76/lxRdfVDZs2KCcOXNG2b9/v3LHHXcodnZ2yrFjxyxxCYqiKMoTTzyhxMXFKcnJycqOHTuUmJgYxcvLS8nJyVEUpf28H/X0er3StWtX5amnnrrsMWt9P4qLi5WDBw8qBw8eVADl7bffVg4ePGisBvr3v/9dcXNzU9asWaMcOXJEmTFjhhIaGqqUl5cbzzF+/HjlvffeM359td8zS1xLVVWVMn36dKVLly7KoUOHGvzeVFZWNnktV/sZbevrKC4uVp588kklPj5eSU5OVjZt2qQMHDhQ6d69u1JRUdHkdVjje1KvsLBQcXBwUJYuXdroOazhPRHWQcZwy48ZvyVjuOXfDxnDZQw3JxnDr0yS7qt47733lK5duyq2trbK0KFDlV27dhkfGzNmjHLfffc1OP7rr79WevToodja2iqRkZHKTz/91MYRXw5o9Pbxxx8bj/n9tTz++OPG6/b19VWmTp2qHDhwoO2D/41Zs2Yp/v7+iq2trRIYGKjMmjVLSUpKMj7eXt6Pehs2bFAA5eTJk5c9Zq3vx+bNmxv9WaqP1WAwKM8//7zi6+ur6HQ6ZcKECZddX3BwsLJo0aIG913p98wS15KcnNzk783mzZubvJar/Yy29XWUlZUp119/veLt7a3Y2NgowcHBykMPPXTZwNse3pN677//vmJvb68UFBQ0eg5reE+E9ZAxXMZwc5Ex/BJrGy9kDLe+96ReZx7DVYqiKK2dJRdCCCGEEEIIIUTTZE+3EEIIIYQQQghhJpJ0CyGEEEIIIYQQZiJJtxBCCCGEEEIIYSaSdAshhBBCCCGEEGYiSbcQQgghhBBCCGEmknQLIYQQQgghhBBmIkm3EEIIIYQQQghhJpJ0CyGEEEIIIYQQZiJJtxDC7FQqFatXr7Z0GEIIIYRoIRnDhbh2knQL0cHdf//9qFSqy26TJ0+2dGhCCCGEuAIZw4XoGLSWDkAIYX6TJ0/m448/bnCfTqezUDRCCCGEaC4Zw4Vo/2SmW4hOQKfT4efn1+Dm7u4O1C4bW7p0KVOmTMHe3p6wsDC+/fbbBs9PSEhg/Pjx2Nvb4+npycMPP0xJSUmDY1asWEFkZCQ6nQ5/f38effTRBo/n5eVx00034eDgQPfu3Vm7dq3xsYsXL3L33Xfj7e2Nvb093bt3v+wPDCGEEKIzkjFciPZPkm4hBM8//zy33HILhw8f5u677+aOO+4gMTERgNLSUiZNmoS7uzt79+7lm2++YdOmTQ0G5KVLlzJv3jwefvhhEhISWLt2LeHh4Q1e48UXX+T222/nyJEjTJ06lbvvvpsLFy4YX//48eP8/PPPJCYmsnTpUry8vNruGyCEEEK0UzKGC9EOKEKIDu2+++5TNBqN4ujo2OD26quvKoqiKIDyxz/+scFzoqOjlblz5yqKoigffPCB4u7urpSUlBgf/+mnnxS1Wq1kZWUpiqIoAQEByrPPPttkDIDy3HPPGb8uKSlRAOXnn39WFEVRpk2bpsyZM8c0FyyEEEJ0EDKGC9ExyJ5uITqBcePGsXTp0gb3eXh4GP9/2LBhDR4bNmwYhw4dAiAxMZGoqCgcHR2Nj48YMQKDwcDJkydRqVScP3+eCRMmXDGGfv36Gf/f0dERFxcXcnJyAJg7dy633HILBw4c4Prrr2fmzJkMHz68VdcqhBBCdCQyhgvR/knSLUQn4OjoeNlSMVOxt7dv1nE2NjYNvlapVBgMBgCmTJnCuXPnWLduHRs3bmTChAnMmzePt956y+TxCiGEEO2JjOFCtH+yp1sIwa5duy77ulevXgD06tWLw4cPU1paanx8x44dqNVqevbsibOzMyEhIcTGxl5TDN7e3tx33318/vnnvPPOO3zwwQfXdD4hhBCiM5AxXAjrJzPdQnQClZWVZGVlNbhPq9UaC5188803DB48mJEjR/LFF1+wZ88ePvroIwDuvvtuFi1axH333ccLL7xAbm4ujz32GPfeey++vr4AvPDCC/zxj3/Ex8eHKVOmUFxczI4dO3jssceaFd/ChQsZNGgQkZGRVFZW8uOPPxr/YBBCCCE6MxnDhWj/JOkWohNYv349/v7+De7r2bMnJ06cAGqrkn711Vc88sgj+Pv78+WXX9K7d28AHBwc2LBhA3/+858ZMmQIDg4O3HLLLbz99tvGc913331UVFTwz3/+kyeffBIvLy9uvfXWZsdna2vLggULSElJwd7enlGjRvHVV1+Z4MqFEEKI9k3GcCHaP5WiKIqlgxBCWI5KpeL7779n5syZlg5FCCGEEC0gY7gQ7YPs6RZCCCGEEEIIIcxEkm4hhBBCCCGEEMJMZHm5EEIIIYQQQghhJjLTLYQQQgghhBBCmIkk3UIIIYQQQgghhJlI0i2EEEIIIYQQQpiJJN1CCCGEEEIIIYSZSNIthBBCCCGEEEKYiSTdQgghhBBCCCGEmUjSLYQQQgghhBBCmIkk3UIIIYQQQgghhJlI0i2EEEIIIYQQQpjJ/wNVsOOiPkK8twAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 5))\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(range(NUM_EPOCHS), emb_train_loss_log, label='Train Loss', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), emb_val_loss_log, label='Validation Loss', color='#384860')\n", + "plt.title('Embedding Loss over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(range(NUM_EPOCHS), clas_train_loss_log, label='Train Loss', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), clas_val_loss_log, label='Validation Loss', color='#384860')\n", + "plt.title('Classification Loss over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('loss_logs.png')\n", + "plt.show()\n", + "#plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "eecbe86e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 5))\n", + "\n", + "plt.subplot(1, 3, 1)\n", + "plt.plot(range(NUM_EPOCHS), train_accuracy_log, label='Train Accuracy', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), val_accuracy_log, label='Validation Accuracy', color='#384860')\n", + "plt.title('Classification Accuracy over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "\n", + "plt.subplot(1, 3, 2)\n", + "plt.plot(range(NUM_EPOCHS), train_ROC_AUC_log, label='Train ROC AUC', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), val_ROC_AUC_log, label='Validation ROC AUC', color='#384860')\n", + "plt.title('ROC AUC over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('ROC AUC')\n", + "plt.legend()\n", + "\n", + "plt.subplot(1, 3, 3)\n", + "plt.plot(range(NUM_EPOCHS), train_AP_score_log, label='Train AP Score', color='#97a6c4')\n", + "plt.plot(range(NUM_EPOCHS), val_AP_score_log, label='Validation AP Score', color='#384860')\n", + "plt.title('Average Precision Score over Epochs')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('AP Score')\n", + "plt.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('metrics_logs.png')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "3e9f4d16", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.load_state_dict(torch.load((Path(DATA_ROOT) / 'best_siamese_model.pth')))" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "45c3f711", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
isic_idpatient_idtarget
0ISIC_3562968IP_22638880
1ISIC_0404479IP_15173860
2ISIC_4500621IP_90428140
3ISIC_9685344IP_40177260
4ISIC_6507179IP_94639650
............
111ISIC_9583969IP_42811941
112ISIC_9596721IP_07250271
113ISIC_9821002IP_50637561
114ISIC_9955163IP_75072121
115ISIC_9998682IP_25161681
\n", + "

116 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " isic_id patient_id target\n", + "0 ISIC_3562968 IP_2263888 0\n", + "1 ISIC_0404479 IP_1517386 0\n", + "2 ISIC_4500621 IP_9042814 0\n", + "3 ISIC_9685344 IP_4017726 0\n", + "4 ISIC_6507179 IP_9463965 0\n", + ".. ... ... ...\n", + "111 ISIC_9583969 IP_4281194 1\n", + "112 ISIC_9596721 IP_0725027 1\n", + "113 ISIC_9821002 IP_5063756 1\n", + "114 ISIC_9955163 IP_7507212 1\n", + "115 ISIC_9998682 IP_2516168 1\n", + "\n", + "[116 rows x 3 columns]" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_samples_subset = test_samples[test_samples[\"target\"]== 0].sample(n=58)\n", + "test_samples_subset = pd.concat([test_samples_subset, test_samples[test_samples[\"target\"]== 1]], ignore_index=True)\n", + "test_samples_subset" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "e8530595", + "metadata": {}, + "outputs": [], + "source": [ + "test_dataset = SkinDataset(DATA_ROOT, test_samples_subset, transform=None)\n", + "test_loader = DataLoader(test_dataset, batch_size=256, shuffle=True, num_workers=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "cb5d1533", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Classification Accuracy: 0.7155\n", + "Test ROC AUC: 0.8532\n", + "Test Average Precision Score: 0.8303\n", + "Test Sensitivity: 0.6034\n", + "Test Specificity: 0.8276\n" + ] + } + ], + "source": [ + "from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix\n", + "model.eval()\n", + "with torch.no_grad():\n", + " test_all_labels = []\n", + " test_all_embeds = []\n", + " test_all_predictions = []\n", + " test_all_probs = []\n", + " for i, (images, labels) in enumerate(test_loader):\n", + " images = images.to(device)\n", + "\n", + " # Get embeddings\n", + " embeddings = model(images)\n", + "\n", + " # classify embeddings\n", + " output = model.classify(embeddings)\n", + "\n", + " # Predictions and Probabilities\n", + " _, preds = torch.max(output, 1)\n", + " probs = torch.softmax(output, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", + " test_all_labels.extend(labels.cpu().numpy())\n", + " test_all_embeds.extend(embeddings.cpu().numpy())\n", + " test_all_predictions.extend(preds.cpu().numpy())\n", + " test_all_probs.extend(probs.cpu().numpy())\n", + "\n", + " test_acc = accuracy_score(test_all_labels, test_all_predictions)\n", + " test_auc = roc_auc_score(test_all_labels, test_all_probs)\n", + " test_aps = average_precision_score(test_all_labels, test_all_probs)\n", + " conf_matrix = confusion_matrix(test_all_labels, test_all_predictions)\n", + " tn, fp, fn, tp = conf_matrix.ravel()\n", + " sensitivity = tp / (tp + fn)\n", + " specificity = tn / (tn + fp)\n", + "\n", + " print(f\"Test Classification Accuracy: {test_acc:.4f}\")\n", + " print(f\"Test ROC AUC: {test_auc:.4f}\")\n", + " print(f\"Test Average Precision Score: {test_aps:.4f}\")\n", + " print(f\"Test Sensitivity: {sensitivity:.4f}\")\n", + " print(f\"Test Specificity: {specificity:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "60705bf6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "48 10 23 35\n" + ] + } + ], + "source": [ + "print(tn, fp, fn, tp)" + ] + }, { "cell_type": "code", "execution_count": 35, From 7feb68591a715574baf3d072df87f2bc14a4e924 Mon Sep 17 00:00:00 2001 From: Mel Date: Fri, 7 Nov 2025 10:46:36 +1000 Subject: [PATCH 08/15] Graphing code add to the experimentation workbook --- .../WIP_notebook.ipynb | 150 +++++++++++++++--- 1 file changed, 124 insertions(+), 26 deletions(-) diff --git a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb index cf4742d89..e4fcbeca7 100644 --- a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb +++ b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb @@ -3726,7 +3726,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 77, "id": "45c3f711", "metadata": {}, "outputs": [ @@ -3759,32 +3759,32 @@ " \n", " \n", " 0\n", - " ISIC_3562968\n", - " IP_2263888\n", + " ISIC_2194940\n", + " IP_3281766\n", " 0\n", " \n", " \n", " 1\n", - " ISIC_0404479\n", - " IP_1517386\n", + " ISIC_6851122\n", + " IP_2010919\n", " 0\n", " \n", " \n", " 2\n", - " ISIC_4500621\n", - " IP_9042814\n", + " ISIC_0338723\n", + " IP_0639877\n", " 0\n", " \n", " \n", " 3\n", - " ISIC_9685344\n", - " IP_4017726\n", + " ISIC_0594289\n", + " IP_3658607\n", " 0\n", " \n", " \n", " 4\n", - " ISIC_6507179\n", - " IP_9463965\n", + " ISIC_8892018\n", + " IP_2107993\n", " 0\n", " \n", " \n", @@ -3830,11 +3830,11 @@ ], "text/plain": [ " isic_id patient_id target\n", - "0 ISIC_3562968 IP_2263888 0\n", - "1 ISIC_0404479 IP_1517386 0\n", - "2 ISIC_4500621 IP_9042814 0\n", - "3 ISIC_9685344 IP_4017726 0\n", - "4 ISIC_6507179 IP_9463965 0\n", + "0 ISIC_2194940 IP_3281766 0\n", + "1 ISIC_6851122 IP_2010919 0\n", + "2 ISIC_0338723 IP_0639877 0\n", + "3 ISIC_0594289 IP_3658607 0\n", + "4 ISIC_8892018 IP_2107993 0\n", ".. ... ... ...\n", "111 ISIC_9583969 IP_4281194 1\n", "112 ISIC_9596721 IP_0725027 1\n", @@ -3845,7 +3845,7 @@ "[116 rows x 3 columns]" ] }, - "execution_count": 53, + "execution_count": 77, "metadata": {}, "output_type": "execute_result" } @@ -3858,18 +3858,18 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 85, "id": "e8530595", "metadata": {}, "outputs": [], "source": [ - "test_dataset = SkinDataset(DATA_ROOT, test_samples_subset, transform=None)\n", + "test_dataset = SkinDataset(DATA_ROOT, test_samples, transform=None)\n", "test_loader = DataLoader(test_dataset, batch_size=256, shuffle=True, num_workers=0)" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 86, "id": "cb5d1533", "metadata": {}, "outputs": [ @@ -3877,11 +3877,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "Test Classification Accuracy: 0.7155\n", - "Test ROC AUC: 0.8532\n", - "Test Average Precision Score: 0.8303\n", + "Test Classification Accuracy: 0.8539\n", + "Test ROC AUC: 0.8573\n", + "Test Average Precision Score: 0.1503\n", "Test Sensitivity: 0.6034\n", - "Test Specificity: 0.8276\n" + "Test Specificity: 0.8584\n" ] } ], @@ -3927,7 +3927,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 87, "id": "60705bf6", "metadata": {}, "outputs": [ @@ -3935,7 +3935,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "48 10 23 35\n" + "2794 461 23 35\n" ] } ], @@ -3943,6 +3943,104 @@ "print(tn, fp, fn, tp)" ] }, + { + "cell_type": "code", + "execution_count": 88, + "id": "baadf2e9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix\n", + "cm = confusion_matrix(test_all_labels, test_all_predictions)\n", + "cm_display = ConfusionMatrixDisplay(cm).plot(cmap=\"Blues\")" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "82428b82", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.metrics import RocCurveDisplay, roc_curve, PrecisionRecallDisplay, precision_recall_curve\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n", + "fpr, tpr, _ = roc_curve(test_all_labels, test_all_probs)\n", + "roc_display = RocCurveDisplay(fpr=fpr, tpr=tpr).plot(ax=ax1)\n", + "ax1.set_title(\"ROC curve\")\n", + "\n", + "prec, recall, _ = precision_recall_curve(test_all_labels, test_all_probs)\n", + "pr_display = PrecisionRecallDisplay(precision=prec, recall=recall).plot(ax=ax2)\n", + "ax2.set_title(\"Precision-Recall curve\")\n", + "\n", + "plt.tight_layout()\n", + "#plt.savefig('loss_logs.png')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "69be06b4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 't-SNE visualization of embeddings')" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.manifold import TSNE\n", + "\n", + "tsne = TSNE(n_components=2, random_state=42)\n", + "embeddings_2d = tsne.fit_transform(np.array(test_all_embeds))\n", + "\n", + "plt.figure(figsize=(8, 6))\n", + "scatter = plt.scatter(np.array(test_all_embeds)[:, 0], np.array(test_all_embeds)[:, 1], c=np.array(test_all_labels), cmap='cividis')\n", + "plt.colorbar(scatter)\n", + "plt.title('t-SNE visualization of embeddings')\n", + "#plt.savefig('testing_tsne_embeddings.png')\n", + "#plt.close()" + ] + }, { "cell_type": "code", "execution_count": 35, From 76025db8418225c00d481ea7117e12d1bd11239c Mon Sep 17 00:00:00 2001 From: Mel Date: Fri, 7 Nov 2025 11:04:55 +1000 Subject: [PATCH 09/15] Moved the data related code from WIP_notebook.ipynb to dataset.py --- .../Siamese_Network_MAILLOT/dataset.py | 204 +++++++++++++++++- 1 file changed, 201 insertions(+), 3 deletions(-) diff --git a/recognition/Siamese_Network_MAILLOT/dataset.py b/recognition/Siamese_Network_MAILLOT/dataset.py index 980de3b25..d40af1957 100644 --- a/recognition/Siamese_Network_MAILLOT/dataset.py +++ b/recognition/Siamese_Network_MAILLOT/dataset.py @@ -1,3 +1,201 @@ -# Melissa Maillot - s4851573 -# COMP3710 2025S2 - Report -# dataset.py \ No newline at end of file +""" +Melissa Maillot - s4851573 +COMP3710 2025S2 - Report +dataset.py - contains all data manipulation and Dataset code +""" + +import torch +#import torch.nn as nn +#import torch.nn.functional as F +#import torch.optim as optim +from torch.utils.data import Dataset#, DataLoader +from torchvision import transforms#, models +import numpy as np +import pandas as pd +from sklearn.model_selection import train_test_split +#from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix +import random +#import itertools +from PIL import Image +#import os +#import glob +from pathlib import Path +#import shutil +#import matplotlib.pyplot as plt + +SEED = 48515739 +random.seed(SEED) +np.random.seed(SEED) + + +def split_data(data_root): + """ + Fetches reference dataframe + Splits data frame in 80/10/10 train/validation/test sets + Oversamples the minority class to have equal number of each class in the train set + Returns three dataframes: the train set, the validation set, the test set + + Image files are not manipulated as it would cause unnecessary overhead + """ + data_dir = Path(data_root) + + # Fetch the image names and labels dataset and load to a dataframe + data_df = pd.read_csv((data_dir / "train-metadata.csv"), index_col=0) + + # Get IDs and labels for dataset train/validation/test splitting + # The isic_id is unique + image_ids = data_df["isic_id"] + labels = data_df["target"] + + # Split into train, validation and test sets + # 80% of data to train, 10% to validate, 10% to test + # Split train and validation/test + train_ids, val_test_ids, train_labels, val_test_labels = train_test_split( + image_ids, labels, test_size=0.2, stratify=labels, random_state=SEED + ) + # Split validation and test + val_ids, test_ids, val_labels, test_labels = train_test_split( + val_test_ids, val_test_labels, test_size=0.5, stratify=val_test_labels, random_state=SEED + ) + + # Subset dataframe for train, validation and test + # The isic_id column will be used to fetch the images when dataloading + # The dataframe index is reset for ease of access at dataloading phase + train_samples = data_df[data_df["isic_id"].isin(train_ids)].reset_index(drop=True) + val_samples = data_df[data_df["isic_id"].isin(val_ids)].reset_index(drop=True) + test_samples = data_df[data_df["isic_id"].isin(test_ids)].reset_index(drop=True) + + # Oversample the minority class in the training set + # There will be an equal amount of rows for each class + normal_samples_size = train_samples[train_samples["target"]== 0].shape[0] + melanoma_sample = train_samples[train_samples["target"]== 1] + oversample_sample = melanoma_sample.sample(n=normal_samples_size - melanoma_sample.shape[0], replace=True, random_state=SEED) + + # Concatenate the data and the oversaampled data into one dataframe + train_samples = pd.concat([train_samples, oversample_sample], ignore_index=True) + train_samples = train_samples.sample(frac=1).reset_index(drop=True) + # Logic: We duplicate some of the image references in the training data + # label dataframe. Since the images will be transformed when loaded, this + # will augment the melanoma samples. We only add duplicated rows as this + # array is what gets iterated on by the Dataloader. There is no need to + # duplicate the image, that is useless use of memory. The augmented array + # is shuffled so that randomisation is ensured when dataloaders iterate + # the dataset. + + return train_samples, val_samples, test_samples + + +class TripletDataset(Dataset): + """ + Custom Dataset for generating (Anchor, Positive, Negative) triplets + when given the pandas dataframe that lists the images in the set and its labels + """ + def __init__(self, root_dir, items_df, transform=None): + #self.root_dir = root_dir + #self.transform = transform + + # get the image folder path + self.image_dir = (Path(root_dir) / 'image') + # get the labels dataframe + self.items_df = items_df + # Label names + self.classes = ['normal', 'melanoma'] + + # Standard image transformation to which we add supplied tranformations + self.transform = transforms.Compose( + (transform.transforms if transform else [])+ + #[transforms.ToPILImage(), + [transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])] + ) + + # Total number of unique images to iterate over + self.len = self.items_df.shape[0] + + def __len__(self): + return self.len + + def __getitem__(self, index): + # 1. Select Anchor (A) + #anchor_path, anchor_class = self.all_paths[index] + + # Get image information from the dataframe + anchor = self.items_df.iloc[index] + # Get image label + anchor_class = anchor["target"] + # Get image + anchor_name = anchor["isic_id"] + anchor_image = Image.open(self.image_dir / (anchor_name + ".jpg")).convert('RGB') + # Transform image + anchor_image = self.transform(anchor_image) + + # 2. Select Positive (P) + # Select an image from the same class as the anchor, but not the anchor itself + try: + positive = self.items_df[(self.items_df["isic_id"]!=anchor_name) & (self.items_df["target"]==anchor_class)].sample() + except: + # Handle edge case where only one image exists in the class (should not happen in real ISIC) + positive = anchor + + # Get image + positive_name = positive["isic_id"].item() + positive_image = Image.open(self.image_dir / (positive_name + ".jpg")).convert('RGB') + # Transform image + positive_image = self.transform(positive_image) + + # 3. Select Negative (N) + # Select a class different from the anchor class (binary case is simple) + negative_class = 1 - anchor_class + # Select a negative sample + negative = self.items_df[self.items_df["target"]==negative_class].sample() + # Get image + negative_name = negative["isic_id"].item() + negative_image = Image.open(self.image_dir / (negative_name + ".jpg")).convert('RGB') + # Transform image + negative_image = self.transform(negative_image) + + # Return triplet and the anchor's original label for verification/testing + return anchor_image, positive_image, negative_image, anchor_class + + +class SkinDataset(Dataset): + """ + Custom Dataset to load the test set + Function the same as TripletDataset, but doesn't return triplets, + just an image and its label. + """ + def __init__(self, root_dir, items_df, transform:transforms.Compose=None): + + # get the image folder path + self.image_dir = (Path(root_dir) / 'image') + # get the labels dataframe + self.items_df = items_df + # Label names + self.classes = ['normal', 'melanoma'] + + # Standard image transformation to which we add supplied tranformations + self.transform = transforms.Compose( + (transform.transforms if transform else [])+ + #[transforms.ToPILImage(), + [transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])] + ) + + self.len = self.items_df.shape[0] + + def __len__(self): + return self.len + + def __getitem__(self, idx): + + # Get image information from the dataframe + item = self.items_df.iloc[idx] + # Get image label + label = item["target"] + # Get image + image_name = item["isic_id"] + image = Image.open(self.image_dir / (image_name + ".jpg")).convert('RGB') + # Transform image + image = self.transform(image) + + return image, torch.tensor(label, dtype=torch.long) \ No newline at end of file From 75366d4b2fcaf706a24655c0b35b5b2bef02a6ff Mon Sep 17 00:00:00 2001 From: Mel Date: Fri, 7 Nov 2025 11:23:23 +1000 Subject: [PATCH 10/15] Moved model related code from WIP_notebook.ipynb to modules.py --- .../Siamese_Network_MAILLOT/modules.py | 87 ++++++++++++++++++- 1 file changed, 84 insertions(+), 3 deletions(-) diff --git a/recognition/Siamese_Network_MAILLOT/modules.py b/recognition/Siamese_Network_MAILLOT/modules.py index a5b0656c2..f8281f798 100644 --- a/recognition/Siamese_Network_MAILLOT/modules.py +++ b/recognition/Siamese_Network_MAILLOT/modules.py @@ -1,3 +1,84 @@ -# Melissa Maillot - s4851573 -# COMP3710 2025S2 - Report -# modules.py \ No newline at end of file +""" +Melissa Maillot - s4851573 +COMP3710 2025S2 - Report +modules.py - contains all neural network and custom loss function code +""" + +import torch +import torch.nn as nn +#import torch.nn.functional as F +#import torch.optim as optim +#from torch.utils.data import Dataset, DataLoader +from torchvision import models +#import numpy as np +#import pandas as pd +#from sklearn.model_selection import train_test_split +#from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix +#import random +#import itertools +#from PIL import Image +#import os +#import glob +#from pathlib import Path +#import shutil +#import matplotlib.pyplot as plt + +class EmbeddingNet(nn.Module): + """ + Non-pretrained CNN to generate image embeddings. + Simple classifier head for classification + """ + def __init__(self, out_dim): + super(EmbeddingNet, self).__init__() + + # load ResNet50 model + resnet = models.resnet50() + + # change the feature extractor head + self.extractor = nn.Sequential(*list(resnet.children())[:-1]) + self.fc_out = nn.Sequential( + nn.Linear(2048, 512), + nn.ReLU(inplace=True), + nn.Dropout(0.3), # 0.5 + nn.Linear(512, 256), + nn.ReLU(inplace=True), + nn.Dropout(0.3), # 0.5 + nn.Linear(256, out_dim) + ) + + # classification head + self.classifier = nn.Linear(out_dim, 2) + + def forward(self, x): + # extract features + x = self.extractor(x) + # Flatten the feature map + x = x.view(x.size(0), -1) + # Final embedding output + x = self.fc_out(x) + + return x + + def classify(self, x): + # classifiy + return self.classifier(x) + + +class TripletLoss(nn.Module): + """ + Triplet loss function based on the distance between embeddings. + L(A, P, N) = max(0, ||f(A) - f(P)||^2 - ||f(A) - f(N)||^2 + margin) + """ + def __init__(self, margin=1.0): + super(TripletLoss, self).__init__() + self.margin = margin + self.p = 2 # L2 distance + + def forward(self, anchor, positive, negative): + # Calculate squared L2 distance + d_pos = nn.functional.pairwise_distance(anchor, positive, p=self.p) + d_neg = nn.functional.pairwise_distance(anchor, negative, p=self.p) + + # Triplet loss formula + loss = torch.relu(d_pos - d_neg + self.margin).mean() + return loss \ No newline at end of file From b06a9b1d67111f7705cf020f3dad3aafaa3af2f0 Mon Sep 17 00:00:00 2001 From: Mel Date: Fri, 7 Nov 2025 13:57:40 +1000 Subject: [PATCH 11/15] Moved test set evaluation code from WIP_notebook.ipynb to predict.py --- .../Siamese_Network_MAILLOT/predict.py | 123 +++++++++++++++++- 1 file changed, 120 insertions(+), 3 deletions(-) diff --git a/recognition/Siamese_Network_MAILLOT/predict.py b/recognition/Siamese_Network_MAILLOT/predict.py index 29b0e9876..8672f1920 100644 --- a/recognition/Siamese_Network_MAILLOT/predict.py +++ b/recognition/Siamese_Network_MAILLOT/predict.py @@ -1,3 +1,120 @@ -# Melissa Maillot - s4851573 -# COMP3710 2025S2 - Report -# predict.py +""" +Melissa Maillot - s4851573 +COMP3710 2025S2 - Report +predict.py - produces evaluation metrics and plots for models on the test set +""" + +import torch +from torch.utils.data import DataLoader +import numpy as np +import pandas as pd +from sklearn.metrics import ( + roc_auc_score, accuracy_score, average_precision_score, + confusion_matrix, ConfusionMatrixDisplay, + RocCurveDisplay, roc_curve, + PrecisionRecallDisplay, precision_recall_curve + ) +from sklearn.manifold import TSNE +from pathlib import Path +import matplotlib.pyplot as plt + +from dataset import SkinDataset + +def test_set_evaluation(model, test_samples, device, data_root): + """ + Gives the following evaluation metrics for the provided model: + - classification accuracy + - ROC AUC + - average precision score + - sensitivity + - specificity + + Provides and saves graphical displays of: + - the confusion matrix + - the ROC curve and the precision-recall curve + - t-SNE visualisation of embeddings + + It does so on the full test dataset and on a balanced subset of the dataset. + """ + + # Get a balanced sample of the test set + test_samples_subset = test_samples[test_samples["target"]== 0].sample(n=test_samples[test_samples["target"]== 1].shape[0]) + test_samples_subset = pd.concat([test_samples_subset, test_samples[test_samples["target"]== 1]], ignore_index=True) + + for i in ["Subset", ""]: + + # get the correct dataset + if i == "Subset": + test_dataset = SkinDataset(data_root, test_samples_subset, transform=None) + else: + test_dataset = SkinDataset(data_root, test_samples, transform=None) + + # get the data loader + test_loader = DataLoader(test_dataset, batch_size=256, shuffle=True, num_workers=0) + + model.eval() + with torch.no_grad(): + test_all_labels = [] + test_all_embeds = [] + test_all_predictions = [] + test_all_probs = [] + for i, (images, labels) in enumerate(test_loader): + images = images.to(device) + + # Get embeddings + embeddings = model(images) + + # classify embeddings + output = model.classify(embeddings) + + # Predictions and Probabilities + _, preds = torch.max(output, 1) + probs = torch.softmax(output, dim=1)[:, 1] # Probability of class 1 (Melanoma) + test_all_labels.extend(labels.cpu().numpy()) + test_all_embeds.extend(embeddings.cpu().numpy()) + test_all_predictions.extend(preds.cpu().numpy()) + test_all_probs.extend(probs.cpu().numpy()) + + # --- calculate metrics --- + test_acc = accuracy_score(test_all_labels, test_all_predictions) + test_auc = roc_auc_score(test_all_labels, test_all_probs) + test_aps = average_precision_score(test_all_labels, test_all_probs) + conf_matrix = confusion_matrix(test_all_labels, test_all_predictions) + tn, fp, fn, tp = conf_matrix.ravel() + sensitivity = tp / (tp + fn) + specificity = tn / (tn + fp) + + # get metrics + print(f"Test{" "+i if i else ""} Classification Accuracy: {test_acc:.4f}") + print(f"Test{" "+i if i else ""} ROC AUC: {test_auc:.4f}") + print(f"Test{" "+i if i else ""} Average Precision Score: {test_aps:.4f}") + print(f"Test{" "+i if i else ""} Sensitivity: {sensitivity:.4f}") + print(f"Test{" "+i if i else ""} Specificity: {specificity:.4f}") + + # --- plotting --- + # confusion matrix + cm = confusion_matrix(test_all_labels, test_all_predictions) + cm_display = ConfusionMatrixDisplay(cm).plot(cmap="Blues") + plt.tight_layout() + plt.savefig((Path(data_root) / ('confusion_matrix'+('_'+i if i else '')+'.png'))) + + # ROC AUC and precision-recall + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5)) + fpr, tpr, _ = roc_curve(test_all_labels, test_all_probs) + roc_display = RocCurveDisplay(fpr=fpr, tpr=tpr).plot(ax=ax1) + ax1.set_title((i+" " if i else "")+"ROC curve") + prec, recall, _ = precision_recall_curve(test_all_labels, test_all_probs) + pr_display = PrecisionRecallDisplay(precision=prec, recall=recall).plot(ax=ax2) + ax2.set_title((i+" " if i else "")+"Precision-Recall curve") + plt.tight_layout() + plt.savefig((Path(data_root) / ('ROCAUC_PRC'+('_'+i if i else '')+'.png'))) + + # t-SNE manifold + tsne = TSNE(n_components=2, random_state=42) + embeddings_2d = tsne.fit_transform(np.array(test_all_embeds)) + plt.figure(figsize=(8, 6)) + scatter = plt.scatter(np.array(embeddings_2d)[:, 0], np.array(embeddings_2d)[:, 1], c=np.array(test_all_labels)) + plt.colorbar(scatter) + plt.title((i+" " if i else "")+'t-SNE visualisation of embeddings') + plt.tight_layout() + plt.savefig((Path(data_root) / ('testing_tsne_embeddings'+('_'+i if i else '')+'.png'))) \ No newline at end of file From eab3b3561900cd54d03047b632ac8004c6b1147b Mon Sep 17 00:00:00 2001 From: Mel Date: Fri, 7 Nov 2025 14:02:32 +1000 Subject: [PATCH 12/15] Moved model train and general function from WIP_notebook.ipynb to train.py + cleaned up imports in the other files --- .../Siamese_Network_MAILLOT/dataset.py | 13 +- .../Siamese_Network_MAILLOT/modules.py | 15 - recognition/Siamese_Network_MAILLOT/train.py | 333 +++++++++++++++++- 3 files changed, 332 insertions(+), 29 deletions(-) diff --git a/recognition/Siamese_Network_MAILLOT/dataset.py b/recognition/Siamese_Network_MAILLOT/dataset.py index d40af1957..f8152bede 100644 --- a/recognition/Siamese_Network_MAILLOT/dataset.py +++ b/recognition/Siamese_Network_MAILLOT/dataset.py @@ -5,23 +5,14 @@ """ import torch -#import torch.nn as nn -#import torch.nn.functional as F -#import torch.optim as optim -from torch.utils.data import Dataset#, DataLoader -from torchvision import transforms#, models +from torch.utils.data import Dataset +from torchvision import transforms import numpy as np import pandas as pd from sklearn.model_selection import train_test_split -#from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix import random -#import itertools from PIL import Image -#import os -#import glob from pathlib import Path -#import shutil -#import matplotlib.pyplot as plt SEED = 48515739 random.seed(SEED) diff --git a/recognition/Siamese_Network_MAILLOT/modules.py b/recognition/Siamese_Network_MAILLOT/modules.py index f8281f798..f53449c75 100644 --- a/recognition/Siamese_Network_MAILLOT/modules.py +++ b/recognition/Siamese_Network_MAILLOT/modules.py @@ -6,22 +6,7 @@ import torch import torch.nn as nn -#import torch.nn.functional as F -#import torch.optim as optim -#from torch.utils.data import Dataset, DataLoader from torchvision import models -#import numpy as np -#import pandas as pd -#from sklearn.model_selection import train_test_split -#from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix -#import random -#import itertools -#from PIL import Image -#import os -#import glob -#from pathlib import Path -#import shutil -#import matplotlib.pyplot as plt class EmbeddingNet(nn.Module): """ diff --git a/recognition/Siamese_Network_MAILLOT/train.py b/recognition/Siamese_Network_MAILLOT/train.py index 99d7ac35d..15ea739df 100644 --- a/recognition/Siamese_Network_MAILLOT/train.py +++ b/recognition/Siamese_Network_MAILLOT/train.py @@ -1,3 +1,330 @@ -# Melissa Maillot - s4851573 -# COMP3710 2025S2 - Report -# train.py \ No newline at end of file +""" +Melissa Maillot - s4851573 +COMP3710 2025S2 - Report +train.py - main file, trains and evaluates the siamese network +""" + +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim +from torch.utils.data import DataLoader +from torchvision import transforms +import numpy as np +from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score +import random +from pathlib import Path +import matplotlib.pyplot as plt + +from dataset import split_data, TripletDataset +from modules import EmbeddingNet, TripletLoss +from predict import test_set_evaluation + +# --- Hyperparameters --- +DATA_ROOT = './data' # IMPORTANT: structure of the data root should be data-root> train-metadata.csv | image +IMAGE_SIZE = 256 +EMBEDDING_DIM = 128 +MARGIN = 1.25 +NUM_EPOCHS = 20 +LEARNING_RATE = 1e-4 +TRAIN_DATA_SUBSET_FRACTION = 0.3 +TRAIN_BATCH_SIZE = 32 +VAL_TEST_BATCH_SIZE = 256 + +def train_epoch(model, dataloader, criterion, classification_crit, optimizer, scheduler, device): + """ + Trains one epoch of the model + Return epoch training metrics: + average embedding loss, average classification loss, classification accuracy, ROC AUC, AP Score + """ + model.train() + + all_labels = [] + all_predictions = [] + all_probs = [] + emb_running_loss = 0.0 + class_running_loss = 0.0 + total_samples = 0 + + for i, (img_a, img_p, img_n, label_a) in enumerate(dataloader): + + img_a, img_p, img_n, label_a = img_a.to(device), img_p.to(device), img_n.to(device), label_a.to(device) + + optimizer.zero_grad() + + # Get embeddings + emb_a = model(img_a) + emb_p = model(img_p) + emb_n = model(img_n) + # Calculate loss + emb_loss = criterion(emb_a, emb_p, emb_n) + + # classify anchors + out_a = model.classify(emb_a) + # Calculate classification loss + class_loss = classification_crit(out_a, label_a) + + # total loss and update weights + loss = emb_loss + class_loss + loss.backward() + optimizer.step() + + # loss logging + total_samples += img_a.size(0) + emb_running_loss += emb_loss.item() * img_a.size(0) + class_running_loss += class_loss.item() * img_a.size(0) + + # Predictions and Probabilities + _, preds = torch.max(out_a, 1) + probs = torch.softmax(out_a, dim=1)[:, 1] # Probability of class 1 (Melanoma) + all_labels.extend(label_a.cpu().numpy()) + all_predictions.extend(preds.cpu().numpy()) + all_probs.extend(probs.cpu().detach().numpy()) + + if (i + 1) % 50 == 0: + print(f'Batch {i+1}/{len(dataloader)}, Embedding training loss: {(emb_loss.item()):.4f}, Classification training loss: {(class_loss.item()):.4f}') + + # scheduler step is specifically for the OneCycleLR scheduler used + # if using a different scheduler, change when the step happens + if (i + 1) % 100 == 0: + scheduler.step() + + # calculate metrics + emb_epoch_loss = emb_running_loss / total_samples + class_epoch_loss = class_running_loss / total_samples + acc = accuracy_score(all_labels, all_predictions) + auc = roc_auc_score(all_labels, all_probs) + aps = average_precision_score(all_labels, all_probs) + return emb_epoch_loss, class_epoch_loss, acc, auc, aps + +def evaluate(model, dataloader, criterion, classification_crit, device): + """ + Evaluates on training epoch on the provided data (usually the validation set) + Return epoch validation metrics: + average embedding loss, average classification loss, classification accuracy, ROC AUC, AP Score + """ + model.eval() + + all_labels = [] + all_predictions = [] + all_probs = [] + emb_running_loss = 0.0 + class_running_loss = 0.0 + total_samples = 0 + + with torch.no_grad(): + for _, (img_a, img_p, img_n, label_a) in enumerate(dataloader): + + img_a, img_p, img_n, label_a = img_a.to(device), img_p.to(device), img_n.to(device), label_a.to(device) + + # Get embeddings + emb_a = model(img_a) + emb_p = model(img_p) + emb_n = model(img_n) + # Calculate loss + emb_loss = criterion(emb_a, emb_p, emb_n) + + # classify anchors + out_a = model.classify(emb_a) + # Calculate classification loss + class_loss = classification_crit(out_a, label_a) + + # loss logging + total_samples += img_a.size(0) + emb_running_loss += emb_loss.item() * img_a.size(0) + class_running_loss += class_loss.item() * img_a.size(0) + + # Predictions and Probabilities + _, preds = torch.max(out_a, 1) + probs = torch.softmax(out_a, dim=1)[:, 1] # Probability of class 1 (Melanoma) + all_labels.extend(label_a.cpu().numpy()) + all_predictions.extend(preds.cpu().numpy()) + all_probs.extend(probs.cpu().detach().numpy()) + + # calculate metrics + emb_epoch_loss = emb_running_loss / total_samples + class_epoch_loss = class_running_loss / total_samples + acc = accuracy_score(all_labels, all_predictions) + auc = roc_auc_score(all_labels, all_probs) + aps = average_precision_score(all_labels, all_probs) + return emb_epoch_loss, class_epoch_loss, acc, auc, aps + +def main(): + """ + Run Training on SiameseNet for classification of ISIC 2020 data. + Training will be preformed and then evaluation results on the trained model will be produced. + """ + + # --- Configuration --- + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + print(f"Using device: {device}") + print("\n") + # Set Seed + SEED = 48515739 + random.seed(SEED) + np.random.seed(SEED) + + # fetch dataframes referencing the data and split between train, validation and test + train_samples, val_samples, test_samples = split_data(DATA_ROOT) + # take only a subset of the training set + train_samples = train_samples.sample(frac=TRAIN_DATA_SUBSET_FRACTION).reset_index(drop=True) + print(f"Number of normal samples in training data subset: {train_samples[train_samples["target"]== 0].shape[0]}") + print(f"Number of melanoma samples in training data subset: {train_samples[train_samples["target"]== 1].shape[0]}") + + # Setup DataLoaders + # add additional transformations to the training set + train_dataset = TripletDataset(DATA_ROOT, train_samples, + transform=transforms.Compose([ + transforms.RandomRotation(degrees=10, fill=(255, 255, 255)), + transforms.RandomHorizontalFlip(p=0.5), + transforms.RandomVerticalFlip(p=0.5), + transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.05) + ])) + + val_dataset = TripletDataset(DATA_ROOT, val_samples, transform=None) + + train_loader = DataLoader(train_dataset, batch_size=TRAIN_BATCH_SIZE, shuffle=True, num_workers=0) + val_loader = DataLoader(val_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=0) + + # Setup Model, Loss, Optimizer + model = EmbeddingNet(out_dim=EMBEDDING_DIM).to(device) + criterion = TripletLoss(margin=MARGIN).to(device) + classifier_crit = nn.CrossEntropyLoss().to(device) + optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE) + scheduler = optim.lr_scheduler.OneCycleLR(optimizer, + max_lr=LEARNING_RATE, + steps_per_epoch=train_samples.shape[0]//TRAIN_BATCH_SIZE//100, + epochs=NUM_EPOCHS, + anneal_strategy="cos") + + # --- Training Loop --- + # metric logging + best_val_AP_score = -1.0 + emb_train_loss_log = [] + emb_val_loss_log = [] + clas_train_loss_log = [] + clas_val_loss_log = [] + train_accuracy_log = [] + val_accuracy_log = [] + train_ROC_AUC_log = [] + val_ROC_AUC_log = [] + train_AP_score_log = [] + val_AP_score_log = [] + + print("\n--- Starting Training ---") + for epoch in range(1, NUM_EPOCHS + 1): + # Train + print(f"\n==== Training Epoch {epoch} ====") + emb_train_loss, class_train_loss, train_acc, train_auc, train_aps = train_epoch(model, train_loader, criterion, classifier_crit, optimizer, scheduler, device) + + # Print training metrics + print(f"Epoch {epoch} training finished.") + print(f"Average Training Embedding Loss: {emb_train_loss:.4f}") + print(f"Average Training Classification Loss: {class_train_loss:.4f}") + print(f"Training Classification Accuracy: {train_acc:.4f}") + print(f"Training ROC AUC: {train_auc:.4f}") + print(f"Training Average Precision Score: {train_aps:.4f}") + + # Log training metrics + emb_train_loss_log.append(emb_train_loss) + clas_train_loss_log.append(class_train_loss) + train_accuracy_log.append(train_acc) + train_ROC_AUC_log.append(train_auc) + train_AP_score_log.append(train_aps) + + # Evaluate + emb_val_loss, class_val_loss, val_acc, val_auc, val_aps = evaluate(model, val_loader, criterion, classifier_crit, device) + + print("--- Validation phase ---") + # Print validation metrics + print(f"Average Validation Embedding Loss: {emb_val_loss:.4f}") + print(f"Average Validation Classification Loss: {class_val_loss:.4f}") + print(f"Validation Classification Accuracy: {val_acc:.4f}") + print(f"Validation ROC AUC: {val_auc:.4f}") + print(f"Validation Average Precision Score: {val_aps:.4f}") + + # Log validation metrics + emb_val_loss_log.append(emb_val_loss) + clas_val_loss_log.append(class_val_loss) + val_accuracy_log.append(val_acc) + val_ROC_AUC_log.append(val_auc) + val_AP_score_log.append(val_aps) + + # Save best model + # We choose the best model on the basis of the highest validation precison-recall score + # That way we hope to limit false negatives + if val_aps > best_val_AP_score: + print(f"Previous best average precision score: {best_val_AP_score:.4f}") + best_val_AP_score = val_aps + print("Saving best model...") + torch.save(model.state_dict(), (Path(DATA_ROOT) / 'best_siamese_model.pth')) + + print("\n--- Training Finished ---") + print(f"Best Validation Average Precision Score: {best_val_AP_score:.4f}%") + + # --- Training visualisation --- + # Plot loss over epochs + plt.figure(figsize=(10, 5)) + + plt.subplot(1, 2, 1) + plt.plot(range(NUM_EPOCHS), emb_train_loss_log, label='Train Loss', color='#97a6c4') + plt.plot(range(NUM_EPOCHS), emb_val_loss_log, label='Validation Loss', color='#384860') + plt.title('Embedding Loss over Epochs') + plt.xlabel('Epochs') + plt.ylabel('Loss') + plt.legend() + + plt.subplot(1, 2, 2) + plt.plot(range(NUM_EPOCHS), clas_train_loss_log, label='Train Loss', color='#97a6c4') + plt.plot(range(NUM_EPOCHS), clas_val_loss_log, label='Validation Loss', color='#384860') + plt.title('Classification Loss over Epochs') + plt.xlabel('Epochs') + plt.ylabel('Loss') + plt.legend() + + plt.tight_layout() + plt.savefig((Path(DATA_ROOT) / 'loss_logs.png')) + plt.show() + plt.close() + + # plot metrics over epochs + plt.figure(figsize=(15, 5)) + + plt.subplot(1, 3, 1) + plt.plot(range(NUM_EPOCHS), train_accuracy_log, label='Train Accuracy', color='#97a6c4') + plt.plot(range(NUM_EPOCHS), val_accuracy_log, label='Validation Accuracy', color='#384860') + plt.title('Classification Accuracy over Epochs') + plt.xlabel('Epochs') + plt.ylabel('Accuracy') + plt.legend() + + plt.subplot(1, 3, 2) + plt.plot(range(NUM_EPOCHS), train_ROC_AUC_log, label='Train ROC AUC', color='#97a6c4') + plt.plot(range(NUM_EPOCHS), val_ROC_AUC_log, label='Validation ROC AUC', color='#384860') + plt.title('ROC AUC over Epochs') + plt.xlabel('Epochs') + plt.ylabel('ROC AUC') + plt.legend() + + plt.subplot(1, 3, 3) + plt.plot(range(NUM_EPOCHS), train_AP_score_log, label='Train AP Score', color='#97a6c4') + plt.plot(range(NUM_EPOCHS), val_AP_score_log, label='Validation AP Score', color='#384860') + plt.title('Average Precision Score over Epochs') + plt.xlabel('Epochs') + plt.ylabel('AP Score') + plt.legend() + + plt.tight_layout() + plt.savefig((Path(DATA_ROOT) / 'metrics_logs.png')) + plt.show() + plt.close() + + # --- Model evaluation --- + # Load best model + model.load_state_dict(torch.load((Path(DATA_ROOT) / 'best_siamese_model.pth'))) + + # get evaluation metrics + test_set_evaluation(model, test_samples, device, DATA_ROOT) + +if __name__ == "__main__": + main() \ No newline at end of file From 1a104b9624041bdb576b2eee708278daed9b8f17 Mon Sep 17 00:00:00 2001 From: Melissa Maillot <71195815+MelMaillot@users.noreply.github.com> Date: Fri, 7 Nov 2025 16:29:28 +1000 Subject: [PATCH 13/15] Updates to the readme to incorporate the model training testing results, along with a few other details --- recognition/Siamese_Network_MAILLOT/README.md | 130 ++++++++++++++++-- .../README_figures/ROCAUC_PRC.png | Bin 0 -> 24376 bytes .../README_figures/ROCAUC_PRC_Subset.png | Bin 0 -> 22028 bytes .../best_model_train_val_metrics.png | Bin 0 -> 17674 bytes .../README_figures/confusion_matrix.png | Bin 0 -> 12584 bytes .../confusion_matrix_Subset.png | Bin 0 -> 11943 bytes .../README_figures/loss_logs.png | Bin 0 -> 68469 bytes .../README_figures/metrics_logs.png | Bin 0 -> 93811 bytes .../testing_tsne_embeddings.png | Bin 0 -> 91194 bytes .../testing_tsne_embeddings_Subset.png | Bin 0 -> 37078 bytes 10 files changed, 116 insertions(+), 14 deletions(-) create mode 100644 recognition/Siamese_Network_MAILLOT/README_figures/ROCAUC_PRC.png create mode 100644 recognition/Siamese_Network_MAILLOT/README_figures/ROCAUC_PRC_Subset.png create mode 100644 recognition/Siamese_Network_MAILLOT/README_figures/best_model_train_val_metrics.png create mode 100644 recognition/Siamese_Network_MAILLOT/README_figures/confusion_matrix.png create mode 100644 recognition/Siamese_Network_MAILLOT/README_figures/confusion_matrix_Subset.png create mode 100644 recognition/Siamese_Network_MAILLOT/README_figures/loss_logs.png create mode 100644 recognition/Siamese_Network_MAILLOT/README_figures/metrics_logs.png create mode 100644 recognition/Siamese_Network_MAILLOT/README_figures/testing_tsne_embeddings.png create mode 100644 recognition/Siamese_Network_MAILLOT/README_figures/testing_tsne_embeddings_Subset.png diff --git a/recognition/Siamese_Network_MAILLOT/README.md b/recognition/Siamese_Network_MAILLOT/README.md index 3bc1adf9e..2bc436ba8 100644 --- a/recognition/Siamese_Network_MAILLOT/README.md +++ b/recognition/Siamese_Network_MAILLOT/README.md @@ -77,32 +77,134 @@ PatternAnalysis-2025/recognition/Siamese_Network_Maillot/ `dataset.py` contains all the classes required for data manipulation and data loading. This class handles making a 80/10/10 train/validation/test split of the data. It also oversamples the minority class for the training set, such that the training set is balanced. At runtime, the training data will be augmented with rotations, flips and colour jitters. The validation and testing set are not oversampled nor augmented. -`modules.py` contains the neural network architectures and the triplet loss function implementation. +`modules.py` contains the neural network architectures and the triplet loss function implementation. The neural network consists of a ResNet50 and a simple classifier head. The triplet loss function is implemented by hand, following the following equation +``` +L(A, P, N) = max(0, ||f(A) - f(P)||^2 - ||f(A) - f(N)||^2 + margin) +``` -`train.py` contains the main training loop and it's helper functions. The training loop will save the best model as well as the metric plots to the data location (for ease of ignoring with git if needed, this does not affect the dataloading). +`train.py` contains the main training loop and its helper functions. The training loop will save the best model as well as the loss log and metric log plots to the data location folder (for ease of ignoring with git if needed, this does not affect the dataloading). Calling this file will run the whole data retrieval, model training and testing code. -`predict.py` contains code to evaluate the model on the test split of the dataset. +`predict.py` contains code to evaluate the model on the test split of the dataset. It produces metrics as well as plots. Plots will also be saved to the data location folder for consistency. The metrics computed are: accuracy, ROC AUC, AP score, sensitivity, specificity: The plots are: confusion matrix, ROC curve, precision-recall curve, t-SNE visualisation of embeddings. ### Python and dependencies -This project uses Python VERRRRRRR +This project uses Python version `3.13.7` Additonally, the following packages are required in the following versions: +- torch: 2.8.0+cu126 +- torchvision: 0.23.0+cu126 +- numpy: 2.1.2 +- scikit-learn: 1.7.2 +- matplotlib: 3.10.6 +- pandas: 2.3.3 ## Results +Here we present results of the most successful run of training. + +### Hyperparameters + +The hyperparameters for the model that gaves the best metrics were as follows: + +```py +EMBEDDING_DIM = 128 +MARGIN = 1.25 +NUM_EPOCHS = 20 +LEARNING_RATE = 1e-4 +TRAIN_DATA_SUBSET_FRACTION = 0.3 +TRAIN_BATCH_SIZE = 32 +VAL_TEST_BATCH_SIZE = 256 +``` + +The optimiser used was `Adam` and the learining rate scheduler was `OneCycleLR` with the following parameters: + +```py +max_lr=LEARNING_RATE +steps_per_epoch=train_samples.shape[0]//TRAIN_BATCH_SIZE//100 +epochs=NUM_EPOCHS +anneal_strategy="cos" +``` + +### Model training + +The model was trained for 20 epoch, but the model with the highest AP score was from epoch 10. The training and validation metrics of that model are as follows: + +![Best model training and validation metrics](README_figures/best_model_train_val_metrics.png) + +The loss over the different epochs show that the model had a low loss on the validation set on that epoch. + +![Loss plotted against epochs](README_figures/loss_logs.png) + +There is also high validation accuracy on that epoch. The validation ROC AUC and the AP score are at their highest in that epoch. + +![Loss plotted against epochs](README_figures/metrics_logs.png) + +We notice that the validation triplet loss, the ROC AUC and the AP score somewhat plateau after the tenth epoch. However, the classificaiton loss and the classification accuracy continue increasing. This was not further investigated, however it may be a result of training both the embedder and the classification head at the same time. It may potentially be insightful to modify the training so that both components are trained separately on their own number of epochs, optimiser and scheduler. This was not tested due to lack of time. + +### Model testing + +The model was tested on the test set. The metrics were evaluated once on the test set and once on a balanced subset of the test set giving us different insights. + +Test metrics on the full test set were as follows: +``` +Classification Accuracy: 0.8539 +ROC AUC: 0.8573 +Average Precision Score: 0.1503 +Sensitivity: 0.6034 +Specificity: 0.8584 +``` +Test metrics on the test set sample were as follows: +``` +Classification Accuracy: 0.7328 +ROC AUC: 0.8546 +Average Precision Score: 0.8437 +Sensitivity: 0.6034 +Specificity: 0.8621 +``` +The sensitivity is low, which shows the model predicts too many false negatives. The influence of the class imbalance is also seen in how the classification accuracy changes between the two. + +The confusion matrices show the same issue. + +Here the confusion matrice on the full test set: +![Confusion matrice full test set](README_figures/confusion_matrix.png) + +Here the confusion matrice on the test set sample: +![Confusion matrice test set sample](README_figures/confusion_matrix_Subset.png) + +The ROC curve and the precision-recall curve on the test subset don't look too alarming. +![ROC curve and PR curve test set sample](README_figures/ROCAUC_PRC_Subset.png) + +However the precision-recall curve on the full test set shows a different story. +![ROC curve and PR curve full test set](README_figures/ROCAUC_PRC.png) + +These plots also show that the ROC curve cannot always be trusted, especially with imbalanced datasets. The ROC looks similarly good in both cases, and the ROC AUC in general has looked promising through this whole process. The precision-recall curve here shows that the model is not performing as well as the ROC suggests. + +Now we consider the t-SNE representation of the embeddings. + +![tSNE full test set](README_figures/testing_tsne_embeddings.png) + +The visualisation of embeddings for the full test set seems to suggest the presence of two groups. The normal lesion are overwhelmingly present in both groups. The melanoma lesion are mostly fould in the left part of the left group, which suggest that despite its mild performance, the model does find some sort of pattern in the data. + +![tSNE test set sample](README_figures/testing_tsne_embeddings_Subset.png) + +The embeddings on sample show that the two groups are destinct from each other to some extent. It may suggest that there are some distinct features that can discriminate both classes, but those features have not been sufficiently learnt but the model. + +### Review of results + +This trained model is not optimal. Some metrics such as AP score (on the testing subset) and ROC AUC seem to convey that the model acheives well. However, the problem at hand is a medical problem and misclassifications as false negatives can have life-threatening repurcussion. Melanomas are one of the main causes of skin cancer, and as such a misclassification could end in the death of a patient. The problem with this model is its very high sensitivity (false negative rate). A false positive is less of an issue as manual revue of lesions classified as positive is likely to take place. The goal of such a classifier is to filter out any benign skin lesion such that manual review is not needed. So any melanoma missed is one too many and the current model misses too many to be reliable. Improvements are requiered for this model to fully serve its intended function. + ## Improvements This model is far from optimal. The number of false negatives is still much to high. This is an issue as melanoma can evolve into life-threatening conditions if not treated early. In that sense, this current model is unrealiable for unseen data. Several points of improvement may include: -- Training on a larger subset of the data: most of the data is currently not used in training as the computing power to train on the full dataset was not available (training times were too long) -- Changing the triplet loss for batch hard mining triplet loss. [[6](#references)] suggests that batch hard mining is a more efficient way to train the model, as it only uses hard triplets to calculate the loss. Implimenting this loss was attempted but unsuccessful: the model did not learn, it is unknown where the issue stemmed from and there was not enough time to troubleshoot the issue -- More extensive hyper-parameter tuning and more exploration of different augmentation techiniques -- Experimenting with the model architecture +- Training on a larger subset of the data: most of the data is currently not used in training as the computing power to train on the full dataset was not available (training times were too long). +- Changing the triplet loss for batch hard mining triplet loss. [[6](#references)] suggests that batch hard mining is a more efficient way to train the model, as it only uses hard triplets to calculate the loss. Implimenting this loss was attempted but unsuccessful: the model did not learn, it is unknown where the issue stemmed from and there was not enough time to troubleshoot the issue. +- More extensive hyper-parameter tuning and more exploration of different augmentation techiniques. +- Experimenting with the model architecture, whether it may be changing the embedder architecture, the classifier head, or even make the embedder and the classifier to seperate networks to have more control over the training of each part respectively. ## References -[1] resnet50. Available at: https://docs.pytorch.org/vision/main/models/generated/torchvision.models.resnet50.html -[2] The relationship between Precision-Recall and ROC curves. Available at: https://dl.acm.org/doi/10.1145/1143844.1143874 -[3] Imbalanced Data? Stop Using ROC-AUC and Use AUPRC Instead. Available at: https://towardsdatascience.com/imbalanced-data-stop-using-roc-auc-and-use-auprc-instead-46af4910a494/ -[4] ROC AUC vs Precision-Recall for Imbalanced Data. Available at: https://machinelearningmastery.com/roc-auc-vs-precision-recall-for-imbalanced-data/ -[5] `average_precision_score`. Available at: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score -[6] In Defense of the Triplet Loss for Person Re-Identification. Available at: https://arxiv.org/pdf/1703.07737 \ No newline at end of file +- [1] resnet50. Available at: https://docs.pytorch.org/vision/main/models/generated/torchvision.models.resnet50.html +- [2] The relationship between Precision-Recall and ROC curves. Available at: https://dl.acm.org/doi/10.1145/1143844.1143874 +- [3] Imbalanced Data? Stop Using ROC-AUC and Use AUPRC Instead. Available at: https://towardsdatascience.com/imbalanced-data-stop-using-roc-auc-and-use-auprc-instead-46af4910a494/ +- [4] ROC AUC vs Precision-Recall for Imbalanced Data. Available at: https://machinelearningmastery.com/roc-auc-vs-precision-recall-for-imbalanced-data/ +- [5] `average_precision_score`. Available at: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score +- [6] In Defense of the Triplet Loss for Person Re-Identification. Available at: https://arxiv.org/pdf/1703.07737 \ No newline at end of file diff --git a/recognition/Siamese_Network_MAILLOT/README_figures/ROCAUC_PRC.png b/recognition/Siamese_Network_MAILLOT/README_figures/ROCAUC_PRC.png new file mode 100644 index 0000000000000000000000000000000000000000..e8d6b32ba4ce9e2700aa66041b29ad73b9db1cfa GIT binary patch literal 24376 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 literal 0 HcmV?d00001 diff --git a/recognition/Siamese_Network_MAILLOT/README_figures/ROCAUC_PRC_Subset.png b/recognition/Siamese_Network_MAILLOT/README_figures/ROCAUC_PRC_Subset.png new file mode 100644 index 0000000000000000000000000000000000000000..870d60f29ee85e65c62973fd2be709b2fa912e6c GIT binary patch literal 22028 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 literal 0 HcmV?d00001 diff --git a/recognition/Siamese_Network_MAILLOT/README_figures/best_model_train_val_metrics.png b/recognition/Siamese_Network_MAILLOT/README_figures/best_model_train_val_metrics.png new file mode 100644 index 0000000000000000000000000000000000000000..44494209e0c39d7ac9dbb591269c37a2122a4843 GIT binary patch literal 17674 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 literal 0 HcmV?d00001 diff --git a/recognition/Siamese_Network_MAILLOT/README_figures/confusion_matrix_Subset.png b/recognition/Siamese_Network_MAILLOT/README_figures/confusion_matrix_Subset.png new file mode 100644 index 0000000000000000000000000000000000000000..f7b068f7b4516b363fb3ed4a96504ffcf64f38e5 GIT binary patch literal 11943 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 literal 0 HcmV?d00001 diff --git a/recognition/Siamese_Network_MAILLOT/README_figures/loss_logs.png b/recognition/Siamese_Network_MAILLOT/README_figures/loss_logs.png new file mode 100644 index 0000000000000000000000000000000000000000..88ad69b79850d02c31ba324a028fb92e5f06de79 GIT binary patch literal 68469 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

eqd!%MI=!_Bp((eJ7O7VD}31lnf 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

wr2Og7kH z0R!Cw!PyF0o@zuzo2MpF4Tk4hqgwlo8;e?lw{bUOxIT@w2;QJHwt?y6Vo)XaV2TAH zC4Q$w>rdjJ(#e*TM@{UgxfxT}s>pr7s53k!M_y33pcGGhzLa8}JIy=_OsneR@ zlrT}W>0s|=VrH4z$ACR~`8FVo3S29WGF~;Erb4qPK{w8C)V2w3 z=c6#JA|yVdD<>qf10wz#k%4`R&siCNZXA zk%d2i6wRh0PBjO!l6)GtUG-@NFkJJ+|5SEqIgR}&3A;x}9tPiQ5jk~;yU;k-YxOkB z_?rydYT?T-k53m8V$sG1vkK&ei#AFvRv+&Tv6l$HcI^brfUBX=;5EQBfOE+YiP_n8 z<6~$l2_scNZ7vpIzNojix0rN&nBwQ8T5)*wL||-e?4Y?BrmpN<11hyEzAUr(WUNsW#LtwQThIydDg)RnCWqj!) z^CEJ11nC(}7eX1sMw(+M3=&zUfa>D%h-B!ovFo&=x4Pfs<_(z=6-CkzdU0{SJl?e@ z2+|bJ+y9;x;P-Ejg=S*f@WZG?tQZ9wbu%-zp*r|Q*pIZTkaKu^d@+mgE77B^gdK_; zTH$;IW)H7i+``nq$59&cST@(Nj~Ms5qk$-;rAq662XBEyh&%K8;74=qy~B|#r>0+i z{`vO#^V6}_DaZtnZc%-PEsc|s)ek%JPExg3jeu8SMc_gzbLiq<_v5Jg;C+y+KuN2u zZ^yP^w#*V$9{8#WFv3jDV*43^%v}x1APAy?gNiIs9{SR%uyZ8xJ?P}>`(ke~*uVdZ zRA-cRTxE#=n8ohBdr4M<^t7rtNPM6=emrAGFDc@P#vG~|paoOWajF@g2Q4rsL*O zaIR6Y>+eT*VzY3Oi|3CNmCI1tLK2gNvX(GyDeowMU#@Zge~DFpb<4;R-^AhgMBw`W m727609BsA#m(bZF5R%iFF8YKq*PVQv*6stlQg{A-_J07~#3g+I literal 0 HcmV?d00001 diff --git a/recognition/Siamese_Network_MAILLOT/README_figures/testing_tsne_embeddings.png b/recognition/Siamese_Network_MAILLOT/README_figures/testing_tsne_embeddings.png new file mode 100644 index 0000000000000000000000000000000000000000..4f692b397ff20dc6f478a37a97a823a82dd267cc GIT binary patch literal 91194 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¬Ff{+@t0j7 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 J2r4#V{|9aQkaz$9 literal 0 HcmV?d00001 diff --git a/recognition/Siamese_Network_MAILLOT/README_figures/testing_tsne_embeddings_Subset.png b/recognition/Siamese_Network_MAILLOT/README_figures/testing_tsne_embeddings_Subset.png new file mode 100644 index 0000000000000000000000000000000000000000..4112dc71060cc15adbeb06b972196f0f0bddf6d1 GIT binary patch literal 37078 zcmafbV|X6X)^-}(wi`7z8{4++G`4L!jg7{3lg75)*w!~a=e)naAGxl{lbQYO*~|C3 zS0WVT#1UX|VL?DZ5F{l;lt4g0-GLuuXi(sj9Hn3_5D;PzNfAL6_w2JAD0g&GykT?K z+F~r?JDM)(6jD+G6j4#d_!57LaDNCz@DwxQx}Q|x%kh-qvx1pQ{1D)R<+IlQcTTo$ z-EMA4drsfd)+yC*K5~5$H*z*s+{PySHp`Ql#E`)Sk-@16IsNebiJ=3D^WkB?1p*i7 zWK@m7uh2@-Kc`873kjw`p{Rd1{D%Jj-(b6aGlXZaAZ5Sax??XK7<#_eGJqD;L*bEP zI1su}rdY^Huj0*wC1GZE7>+_lqf!Rq#_f8xyxX09lILlT;9C~gXen&Rg)CfQu6JXGJ)?UaDAv9T>rQextp zMPj5*hwJ&Ayg&%=AeO$j;To6uWH#{qYebNvzsx2w!JrTuEoS<4Rj!f={oWk6WOq3y z4H%yY<@2Ylngp?a1oWz}))@->>2?KQ@BI*yg3)l+iGF+B@{7S`t5??~CLs~jRnhci&GCFDNV=OQybkyPd*|5!0SNoXFyFJ%hd$7ZY2oRKHwM z*KdNzkfC%Cw_2*HUOKH*tA4o|V;CS@qo}X1@BVnPE{=Cyt}{e5v)}6OayebBV+J(g z02_)7V=|j-0Q+=0KPc$E8BYb|k&m8!a;GE`QiA7cV*7dJ5}X5<{$=EA9&%}WOVU?) z{<~>m3>p=Xdx+BK8F3<6X=yS&-sc}jlYFmd4ObEa{r%g&067jgMDkSPTRo-HY0lQ0 zj+K>Bxtq#nvOZr8Af>#IjEpdJKarjVq(KM*n!xY;Hy(BWB7kQQ-u^rUOV7Ur<`Uh; z>+}8bymT|LK`f5&9XN9~yLD_te?G; z&9-o*{_on&Hjd%b1Em+wP9Xaab{*&J(6)0W6ZSpthsd|Tqp)7@Pq9!?z7QR?I_}x@ zKtQ}6Re9rG*`z@4NcL9-bk@ILkEJn$=|J;xv<|CQs(CzrAuh(bvxrJKS*W~RX*l|m zKz0>G=R_WV*E{8YIG*A4c=7(XFiuHHsr&g5Z~1dd;B(#UvP(9L-RHErg_w)ev_voEH)G9EE#l&tb{Cn4Rq=E zY(Pw*U>BXYa?5kwK3-{V;`<^{&d{jJZV$pvV3K%)hkfN3;C=Zd@I~qIblmum6(BH= zfRN6jSkvfrM{jwTw;k$MY%W$BzLJ;!y!+V%d-`1E$!IL_sK^*+aKGhm`nJg#5*%Y^?uU`GSDP(0R)RWMwkz)Rv^ zK3X=o-%HTP0k#VN&?^nz1vZT z6h8%dZ2ZfbP@kp$(I;TRD|w(^-$j#MMCFJV>OzEYVZD0M0$nIVLPUn2+vAfR@S&bP z*K$2>5BvJAveelH2SO1EPWqfE;4TfaScF620|t5xeYOLjdSU!ce)FTN1pJYLr{=^r z?m%f}#Wvu9zZ-gP2xgr;z!1y}UmqNAhVqW0*KJ?cNBQXIF6tj$$RVS?8ZkFFUxN~~ zgApQ`aqEtB;)y>}SR|1Qi4Iw?a_OdeGLO%zYxzc4 zeBbdr{LxXkOs}tF@%@8u0FUz}&0?WK^`G<7LBF}#HsivFlp}A&b=Zr1;sWy>KYVLF zRRZmXD5~53O_L=ai~pq*nHTpAl?W&N ztYh647qkgRa_FB6p270u2QRcz&`xJ$ysHr#uilMdqN|ttQ(Lcgms2y^Jd4#v>Y}IZ zu(l|KPVcL(WZA0);=}RraRMG!cVqaciK~SGKg-u%;%07_lVv{xhag}prw*l8Cfm0b zYt7a5;+l?(Qyc%>-0Q=+w3HO6_{t(QV&{)nC%Et;qu-J742tXn0|P1b_(;825SqfK zy41!BGF?DYV8Of3U^{UrI4S69`_=R5-@(G#UeC6>SW8d>ZtUY}FD?S@tB@GB@6}I) z&0!FjNLzwLMTx2uZWakRZs)&@MuXuu2V=sKkT|YcyScm`H+g;^)aK$F?Jg1a=XJyw z-I-z4ZD`nF5qlr+uO#PSBbOT;kBimXwj-5%@pECUe{^NPakg&U?A3V5uhg3gj_sJG z$SUYe>ni9UkqLeb#}V}y^nr3h)N=yyNR`H-i{$H9^PBwA4`wpd2pUiN%GY!>}{utH^|`zMC8^osqOa`^B-VAUqKLCY|)aZ)KaBy>ID%G+g|7S^yPl7eCYh) zn6FSB`!FM^G_i+=?m5D1^h=D~r759VQo=XFd&nZ>2Pt9=a%rUavfrdV)*I*WbhWeX zD3`(f`y;Iuq&xP={Y?H#t@Y7lPJFq3hwHbuTtTN^TUFRf64@}F2Ph)%ZHIOrDRqra zzfT`++9JRJcv$19l}pBbm~(jCAZwv#$%-MDLU-o_r`vy6bwLH==k5TB7~pLYBjMWN z+7E92Xf~Jy`~c$uai`nNsTYQHZB)SLj`ZmEVq195mjwCngwVthPEXaHW9 z9wh0POL0qcR=@);>H86&ZUMe^Xm~g%^84G#15JSXWnI`xQ>qdQBVI1d`p*H3^A2$y zJY}lev#kV0ZAkx5T#7P{BMd{O;!+owK{D=H%_D5G%G^7FKF>OP)9PF0xl=$ zSxWQj@Fhu({e378Od(Qka7B}5ct3SDc6tviZ zBnZX?(am5nM=Wa+W;yGht<~=-&GnR`<^w|I;9vwAAO5X4i0PaJ@La{aBGJ$nE=`v(vXY{iALo9ToC z?7?%7Qom_4Gc()BRV!T|zh!rQnFRI2rEBDB3W-GEXGA7^qDx6cZE|=l_v+3zV#%(Y zk3(+j{T$C=0n(KQ0*C!SDB*n%@o_`~daQ6M)&aH;JOu0;J|LnUq^P(CGmcCJjm>pi zh4Wn06zVfGGx3vw>Q->?Kz^P>mcipzW2=j!S^)%NkqdewzjWs5fLZ&U1aZPP=i^x* zR-PmM0aC2dQKdyPQc_;pu-Vym`Gc+L7#;2yBy+k zcKAB(d#TsM8BF(CB84=u;t!59F~DOlST)%Ot_K>9-U7iPNZ9yucl#HX#_~^x+e6tk zZk-y-xf1frV$Q)fZ@{69+8jY$^zuEfgRxU}rK6ioo7eY{X|(jblWt!qKYDZhSxcc+N32)4dZrcxiidi?M2Chn27R>` ztS>7oD-V1p!OYYF`4N2+Q<) z_=`ZdRRm`tGwyZj`Upeouo(?Ng8RP(?Y7^>wb*TNd*1yGBl5*wCq_;L z@=;9G(=b9$37Gr0{mZULJx)R=NCZ6g;9An$+`i~BmqD2LC!ffN zqv_#vzC4_-3D3U0KW?opkzqdd_6dWAJpqQr0~8$IAV5+QNC(Gjb+oCu$!IlCb=4S( zfYH9=180>n!%4R-^|H^HE)GJyFWT=k2B8-sC+zy!D#XzMIXrb?Y{hM^T@V`Q= zR)foz=etMeb$wza{##kwUGLXSCLS9MKN?RWylqCSRt0U}+-s*rn9gK81Z)RMfYv>Q znwlD!MWR;Ljn5lIqP%2qjVq0Gu~z?c5KZ2HG!SrxSWh0rT}w5(4Fn*}Z~IB|LV<{u zP_6k=dx&8deA{dfms>=L;Zadw2Oz^LFc4cPKnzMoW_j~D`!)Rin+;P?P0#Hl4^U^# zp58lCk-?} zOn|{a`GmZNtmn>(jQ|^SZ$>Ox?M5&dNu)3U(Saj>ILh-2UB|Pb5&Vy332R=nrhNy1 z4Fvxwtr{J!v)LebkW&j3aKX;sM!%Mq-hs069q^%qCHun2AbeT?2x1RZvNnM70+sN! zR0<7{p4e=5dN46D0cp{7Jth%#j)5`Nzxx!mcVf#( z?enTup%S4~5lw%Q2tXw*7BfP%OMvRE9gLezmXS3Ax<HY~+-{upUrg+ro z0B$1)npag-1yu4Yk4LURjm83Or|tEk1BsBA6980D$i%2vOx(qCxL4KnJWPQlC+EKZ z2hDN#LU>-GTB(B=%3|0b++@8($mJxm;(a$GuB@yKhd-|cJOWsH8{lRBp&UTf34kwe zXAM)a_*}CC*9BC1-QHX@G!?xGN5C%PzlV9l3bm#1~%_HY7^+qvwWiN$=fQTDR{gn^QqTMGm1ALP{&pPQ@KWTnb5 zd`U;QJ*Fp%I(c4;LZIsG#>FRGwRuz3wTnKH^Nslg+V*!O1|GYO#hT6Z&prTq`s)Dy z)B)(L`eF(e+PA{UF90YOPDH)v+53kIRysi*E5f;kCQ>M^ zXf0nD>NTTOE}L_QcS|i{Y!J{!WO8JSrJ5XOn5=#PAu*H>FfUhj?nLyUQfPp;W`XK+r9f z&+~mgNQ)!jc{nc3qt|YR->>aWUqD#}a?@I^rW3$7TdcQU1B)L4I%6?StZMWR2aHEG z*y{Fa8S8xkU@AjXAQ7$eJs8ChbqvU4vj$3gO#Br<)qs4!x-Srd4{*bbW}ne6*}1ud zXlO~Psi7|a5JN%PUnNIU`|5G(x4)QFLOhS&%Q!g~nE)sebvj(+uHtIx{kS4SiQFNR z7kGVeYO(1;QQ*5laRZq8!nEY{CsiTt{@E#V5w>6)CU6Igg-E}_^?@@+3^nNAng3yt zg#SQF)MkGZp9y(J_>RYtp;tMV^=)kfN32$7HnJF;FRQ7yRE^Cd|sKh~3 z!PRC$V@){8v*G#a`$Z-h^24o&gZMj#?-5P1U6EX;(p++3-bvr9zJ^=UGTkX$)Bh6z zaREBaw}$Lw)kXdvWD>Vn#jzx&9160k&*_D9Yzfd5`O4#BuFQl;#wFgrIx1hWFY@#Bz9U5uhY-siUccB^wEyQ2R zhS3>(zv)y#us6W_X(u0Moc<}JJGH2gv`kN%BR2#WH25{1COX8h!l|Uu`aX$Kxh0eS zL`o#u2+QI;O~r3O)X*sDwNZZ5vO=fjVmgSUn&)B>TxL3_TvoUrtsUu>%OJH?!oWKT zCCrjHwzIdf)y7_lEUCRrF>hp3qcS!5{~3TnwXJ-cQg(8%+=o+9uD)viC*HPjeuj@? z;22`C&xQ<5(M?dVRNk~3{Qs244l$6UOd;cDbx13x4UOj~6nZoMGYJ?^DaA_T@C|-2WyPq2gL;&e~(p^wYiDCiKX*)PgMG{cJ-z1Sx-DLGb9Gd9r9q*A;Ut1kioAB z5)}HHu=dZ7X>gUnr4pu5N6HC=8Yhax&m?Hrbc$&bv9p2vO_k=PI~ zu-!hOst7+xRcOTkYE^-f(fH)l?nkXF1m|y}v_ZEds3N}GW0XOZa7F|@mgwquU^xhl z%3mZREAsC^!j--@=H}0TFVr(jFb==R&*$B-RywJFNB;-73qf~d5WG6o(EOZk2iZ@x zIDKA&{U;lAXrp}7XhUlGAeYL%!}Rk_+6`+Iu<25xx#T;`aaI0v#~C6osNrGr{WASz@x|? zIOr*Q<_}`_E2%fd=*^hs=*?bYU^q4ie%wlpre3<*X|&#t@BFY@M+PG9RsQ_UOa0T* z$IlxJO&XM1Psi-<(UlpT0ZvT(x(E_^B2KAWxM?%>dBq=+r24BjwoRv4_S{t6RN|2!_`*i>U1~MyYZBN znR)2j!2(kHiwynsX&bX0-?N1rhB7V{*|sli--u*!uUl`TQB+OS=tx*PbC`K+t=Xhu z3?4Onckwq~y2F5}cXY<@=tm7Do<#1zboOOgLpZJ=7dj7Q3kN&if~O&{OS@;+Fj><8 zW4~P7wd?z2YY18Ue+?UO)IRdYC?Sv8-=nyZ$7Zgr5cjY%Z| z>+o_&0a#oFx9Z8VwuHBUcqGQBEB!#9V+pllf$attD=v0VV}YAelI=&g@v;3O9LptT z$pj&7y5MRW6>V0}M&C94E)mjh+rb8noFD4)E2ED6?l7Id#kzzS` z(SakzQ?`cne!ETyl|NajYYJ=vK{v>wdC8UfyFvQ5H>_~;?+7%_RpUxIeDR10fnk3ghbj@-~Bp&Uie8Q-Xwcn-h&|G6sF@4rltrbv?|53_I2)zMPO+nD;pH?o}Pzx%> ziVRezN~&d+cw?HfgC_mz`8!BxwzR6DW<@(enh(rvcgx+KX=JRSp#o2DrHX8L>e?S4 zqt-`7AH0q*i%_|pGoKmc9VE1zlqKu+LA10-ki5xWKUk}J>KA`JZQymU9`=*RuCx3t zsJt;(bh4Gz4$pTZxkLrtb{Yj6DhdfOT4_aSsr)AK%+H1C9Ncy+Zwo`?#d&hayoPxZ z%W>-R{eaP!@jc7+wB#rNc$YtOxl}$+Lfjk?$=5M$m@88NJ*Zrd{8mK-M&b-7-|9sE z#$;Nk81|AwRMBaCAo|Mf9czwJk#ULVx*-dXYsN34_%C7u?~k==6mr57@6?l!tvc?c zaKm|j9ZSZShV!-FAOUfe<5v zVJb(SN1#?3li`7pb}I`kRz$Pumqef9u_KYrl90)=OL@OpkkIg}=*i-q7%iPK;k!Ob z8P4r_xXjzZgsa}*EVU7(y$((}xu9F`!hkFf&&7d3C}n**x$hFewU}#-HT?uahUNNM z-N)ecfbY62xZoS;(AZ=K;!JBr;Xy+@(zp$Z3X5ZDu97j{G6@;Sx_l-%wyTXMVSmjN0IeG zvLjkhA<6uJ7{=lE$MJK;=r2;Tm{V&LZH%vkB|dl5M;|`x9KT_Z_SLB=R-?54L%OoX zyvO}VTcNw)BuyF1j88O}R!Q4Vb^w$JQQ9j;BW|Q}x4I`4EIy=wX)bC>0bG!G_lGeR z9XBEdm45COJtV1_Q7CI#-hI`4@aS}wm6ZoZPBR9KSN6Vl+Ez%h$X3vhuSAu&=7W+Y zBQ>t*fae(7F#jW-YqJjS#K~`MnyjergIRR%2!FK8d_|iK4#DVraDNewY#dt0m#LTK zN3HFJj6Fx**^@}I-6=9mcjl@C;UfeBXbKyy2n13}hSUU`$H$uc{(*m-P0xThDcBDX z?U8GA(Od)_QG{&0VKt(HA);&>TNPtHtTt-dyum_|YlB4&x8y;q0WVReEw{PZ_Rav? z!I$<49rP6`?w+Y(y!;_xk(QElNg?ycPSMERUxlxm@DUUXHIlB+LS|WO>ab{@*DOOb~ zVE}9UqFq0_$}t6rQmhm!zV%ynk8+Aa+D^E*k3lvoJ)PPGGD%AgXPqE|SfU&vgdNMQ z>rZ_*F;^v76|BhraRH#20;cQh!Yl@H+XSIdLW@xUS4n8G$lR`ZsCK8GonYFrPqJUG=6xh%0KX-Y_|8ZTQLLc{x z+&KFxpKF}h(jfU@>BzKpyC7I*a~ax)f2F`@8@ zWghTH8|Mo7fZ%Id+8~4prtIi3Ydo}s#K@qg*L@jOy${{L=*V;K%X7DD+UHLm>ipJ} zG5QUXxXq94-trFpC@AB;>THY~o{-eELgP?8q!C*%9#lb#;1$R!e9^Vap`zA#7dFB_ zBO4O?l=4gudtgx*^hbO~I#nxXX(2TxaXBtkh`DH^kV#^EQ~stH5i zl>FkI3a;d~#3kvduF2Qo{dQYOUYRKtEKR&x!s^NWtw99$*C5WGCr5X;1l?_W0j+~b7G7LiA+s(7BT;t5l_N$?htY;+s>LexlqLxz#<#6^Ieg)Rr_+9Q% z{w8Ac;FiHwrQGVcT(Pr^@<&cPk+w*kcaW2W@@GTCp%o8ZYQZtEtwIop<41 zB?cQF&d&f1X45GA_2uRcDC-avEWR+{-G>jpb!lusk+WVaP~YVq}GpV`vy7_C_FxB;;L*(pZoQJ zPMJm(vt}l}d^XiFYW_)%<|r(#fHVSIs6Pz+512^&cVPn+1Ah3vzXNR*{zB5>-C!i# zZI#vmj1u%PZ4`~;p1B8f6o+8JR%JD4Fn)i0O~6LK#xv7u9EO2s3sCslN?%z*OJXVK zQW(L`%oiCVNwdI~?N5KVk+GURprLwGRHY|DSh7*1%)qjHXR|fPSg`ql^+JHV80Np8 z={rV%GwRS{uD?i7`pM7XHQ#CMx9>_B8yV;QcK?AC-4=#@L2=9i?MRPs7?ICl@_R7) z(KN*cbuYUZp4aTwF7W~e1WJ*p=QzUln$W~sjF5v?aXE*L-%wZ z=x7WmHFOAG@xdFH#eZ`JTrJOXl4Mp|oD6VAGV)@ylT%Xp+;0ZR4-rxyq&`5cave-9 z<~c1@Ge?$-$Hp3}M4g0bc9-XtI&=2lB>JJycg#@88&SMZH^~ehbHDqGb%Do*caC<{ zdhH1g*vQ&u9N2T^V4Tk?U%CCz7=@-R;T)O@QI>TXO*1UtD{@4mNET7!$8u>dUXt zwF3v4h{cz;u-W9#VHH$(dlXIjJ|tqcIqbB^I7e>@N_1=2vVxK-OBWVp;db3SXp_pT za-wSUoCJ;4hhl!5v@-D_BlB>0CtAz!B?SXwnEUdwv|6Gq6*g1W_y{G&c9jC5wXJa+ zb~G(*KBu@nLN!@>L-*r?YV2dOgGU&dJpFr|TAs^=VxZqgX< zMOWCd7cDt@f=*1uS-dN09kx-^)V;y8_9TiiJqgm#awXBP9zzN8(&u))_K=qI^J*pK z44~tU%DA#HFzu@N7M{c+LF(4XsPu~d$8 zhcq4LJ$9?FjkDmKD*_VA-BFfyVML&oQ1Tp?Cp7DD?whM6iPjKC)Y)HuetD^Jl~Q0# zgv(;4$!m&-VDkJ+RzyN*_D<`Vo=)><;iM)NknSe+gV(~!os;k0vt2p`!acXc@i><9Taq@GnRfh@jX9kk`4!=8$))YTP}M*I{WAfk12751?nxK3)eJ8AaMXV zY_)Y!z}+1mxj7=QN_Tx_>d*yl4r=*V3XAG&(E4!(jl)+DLdY=_D3a>9ANnY%+yA}3sXh`0Q^iWbJBVv?T6 zG-U9g`1&M^9z8%CIPry5`rZ3XpH}=XrxZ#P{ZAAnnyP z>FKwMTZg$ZGWl{J_iDUo#pS$8@v3Ld>#aoLUOV2dzDapRBAN9neI?zskO)HXqumSd zW&GRByhx%pPI-7ihRK9!#*a?!El-u)mf?dXYKiK0J0Gqa1*yz6i#zhXYBj7pUoAz) z1lvnnpfK|#Mz&82AmGcBdzNY(H!3K%Zi)M9h%~c|RBVaxOe04W$7;YFgMGowZuTsm z8?b!vUF8Q{Cl)x2>tH7#zo_8`a1ipf-Eu%t}0<}5#` zJc}>RB_PF@{1mA)oL?snYwh=|(3aH2(&cFWL<mPNJVF(~P*UObd%HI2bH7KW<52 z2H&*vUtGzcm2Lpy97;t`RKTW5Th^OSd?^AW*1r14x9ld_BG>*9LFC{TqECz0*$sSg z(S!pN+$H+udc&FKV{6LI&0?5_+#a^0HtB(WxRa9s3U_8L^3=MNa*Y&oSG`+9gG}i+|eM@Heg=g+^z9q42 z&DXc1T}%u388168e5&cP2q2r&csObca*}54hK%u98pFnItZvx;b5{7t<8l3TaP_w? zbt5ZO6w`DY4y##F4_9m;szfF_Bf_KhHM}1Nt29y)03gw*8oTrDkIaNXk!LcMbW6}r z&Y~1>??Gd*)f%mthtzyqQ&C56Dv67*9V zW}vb%@}FGW3!Zo3{IE7!@2yXhY{0xREe^=+BCI3jK$XJVRK!Z%ZD;_A&Vm_n#ItfI z*3g3rM8_dA--c;g@!Ir#wUtO8iY2JDYy1+$>R*t>%!kXQk*b76Lo1s>cv$|Fzy!x) zhdfsjZkeRu5`j9(bv)gERQfT9!? z<_g~dUZ%k3+rI{W1-7|A*?oSrXN;-L*p^xdsxB1jL-?KhgkM6o{dxPN1k1$CvOFI= zDanLT9iFzs!oDMDh zm5X*c#&^82vgn%#@*r6SMNULS1kmC-UaVegw4Bo+G)PojoSTbc=CJA&I#B!O@gr(z zIS!gc)%E1E;Nl3+jodticQ7~ziVW4vY-MZiFU;rz8N=4+q3|V7Hf*k48;$AeM%tQV zh}G%rlRdcyCOry$qy_GFQE4Ca!lH3|NBDf&xS*ZpCRJQ>0lMJDz&k$mqjv9ovk)>- zFSk|%g>))Dr-K2|cq5Drm`>-dP;O9ogEy8!_f+Z67JY#Tet^i8z!IB z{`U&kBT!pGL27q&czpdTQ!I<&R)kHpth<`EoxH+kTFBTOtvbYxa*X0uXe)q5{S7616Hp>DJ!w zIG;0f5xwsP9rTvQ*PLH2f4n%n=O8toGuIVr<;chT3*p9*e&89c3==m{m?_92lw8W$ zwOd0L8>aS9_Z>eVlPf3)T0CBE#t4vlJ0tsgQ|-pb=tVr zfhVVya$&2u59?FIsZuh*FJo`tFH(&KQ1U^%1bK83MR(!Z?tUgPj8;m`BQjHG5>bkjUk zEO}%vbH?Vg_`reJRC}b~fTADo8E9JTz=s#-kedD}e&^%&FCf5P8Wq4DuJ%rZXYrBF^vm_ju7Tbf(Fy z#g#rgB=HT=7Ivq92M;l*qQ5)Tl&5Svpf(jWreLg|mECBFe zUOrilbGOp*6yL(s>WVUi>YcEidwpoV`SsfjLy0t4fMn`Yjf<+D+$7 zh2hXRG&j0|X7WHEdy&G8g@v)>omh4}`|fU*3CX((%T{;J6o?+!_Ty-=OmV<~vC($z z0chbncmTr|KLGk6z|&A`vRVNA1y0NbWL_JDXJbARi=A<~G4wAgi23o(AQNAa-R@Sl zBV1G)M${el@PxKnNmcmmnFrr`X&BrP;@=QtDtCs{Fozp$(rNSr0={nmP4By@pe(>l z^LTr@4i5HiTL9SjJvXDYfY-JGXeR*Y6yPdB*33W=p-*dq@U0?;Y03k@ywJES*(r0s zlg6k7rOsoiX*fgrBC@(ARGEz{CEvR|=Yd6~-h}pJch|nGa6B=@ozwoGgn=+5`{g>4 zKeq1foX`~mO#h<__6C6UU7ybs4jaeu9Zp_1L4~jn8m?>|=8=jCf(xkQo}$1gReiQq z6{eJgEwSVXuGu?Za;SF)C()4R2Plc3jwx+ZjGNs8tkw>f(-ND0d#J_7vz0vuY|eUz zbkZ7tU!VstWdPosvcbNFGyVy73%46lB1(oMZHx?^r5Cd5PemvCmERW2$x#}vroJN4 zYxSn!Fx>xj|4&)Dxpr%XX}<&xhhp#oiIW-hH=Cgr0k*;+GR9NAgUN6#0gka+T0Ve=3^8by$04xVMUO2v01@X1)^yW4vD~|%(9VlRrjCaHtP2mpopIIT^4Y8p} zw`q#dN;1&FXxx5jN7ml=KPke?(Qo7AipI1FaNxdWzFj@%OPoxoUt>I%9j%Hmp+^^t>y zt7~&tNgz9#sSr}!PjS3m1s@*FYr2saR<~tp7|Reb*@9J1Uv@;tKvM<)u-M11d#kS+ z)>u?0x1(R!I&dIA7)xTNjW8u*IVT<$YLbn}=Yg&xiWZAE5=-G;1;qhW7a&Aw1IGy@ zsa!t}{ad(!k(*@!V15di2B0mT0N70Lz_5T_&-()~1d+?_0*kM+T==INO2I;yh~A2B zj@@`gALaH7HN;X&;m$z$2cq9v2xmWCm}!csYX~wa31%vDX7ZYh$FLHer45>{^%+tO zaRsA6uRjp|<#TzT0fU^#;@GM)44P#>0cfG@46XqC^{OMN2N>u8_(%9&Qp0CpG*wzKW}IA$-J?ph){Bye9bQ!)bpzl!IJ#(xhGgLhPRma$m&M+N?d-1PlF zAD(ECoOw@*8#13`Jvn{-tVFo_o4ROwdg*bLB=HViB_5tG(;BIw-SQ+OiaaQ-V1Ytj_p^P?kb1RkyfwtMQ#SavEh{sW z^~I&ax;)nfdKU^@2!iOa@cuwYwYR_+90n!bv5WPw&S7Vf{*)<|H$CI=bqe6G0W_I- z)V^e6tsaBZ%qb3C9zQY~`hwT(ju*Zqo*M5et!oxD!(;pQba!mmV);^2^$HgfaB2^c z!*j;S3%N%IU@TDS%*1@ZbN+rJ>GdWRL-~7_MQffo$L}%cxLxtfK zG(jVdaco3L^^O#}fKf>c0Z*%p&*lg(@+XY-#-@#)PJ`8JTLhnQ#(TE7bf1 z*N%S4dF%OU)oN*gt^p26rpSHfxCtq?YiXr;-@Qh)_7I4JYS&t`79%tE$VTxk?)}l^ z#+m6apvIIKwSmMG@a&;L+5|%Absta@#GTM-WD>9O!{&@aytEv9f7PuZi1Q`S@7GtsWKl zp8A|H{}RF3=zvL4-4t7rxi;U0AD9fUG-jv|S#{-BX^gHlsGjZ+RHxFPQk-qIhaW5J0en%*(S%9KB z*WoNK$(Oa(S*Xnc)wO4%==$Mr_|9e`JG3A&4!Ty6MEWE0b)<43Uca@(ZEVIh3=RvV zFI8l0zJ#MN+3=`ub=RU)k0b6oLA&qym4yQ1`^3q)4kwtHfv}D*{pA6B5y>=DVJFlu#5pjE{NSM$C#K zhw=Up#`$$mKaTNM=Pwy_(Rdw2}% zk-o!Ij+&NQ9^txJ{)4%EPCIYEq!;j1s122+F_hFoi^urC(@n;P1w(3xMJJAU2K26|NBIxi0=1nlcZ#HCNm_9RER~wPa;|6$Tp_+z3Rr~##ton3LO(1<%k31 z2oJ0#Ou;wkk2mC$wnF=)KN?tIUz~W|yp|{dUPfxCWbqd>e)3AXU#G4Vwb*_D7sZzu zR&f4Hn1M*Vc3pN}({WB-mSduV*m1S1{LlIq#toK+u;-~p|`R?!!Yr@0zcH`_+UBm%83SL^%{EC^$@*oIPOGcmOAW@R8@%y(FVlPLj??}iIw zR~L&ZNRAzU-K`@?#Z~X-JY}(V{`8#ma)&PaJX+)(6{3PG153?r5q!SGV@PFbj12w@ zECf>#=2Ve1yJ1U^x?FEbBwTWp(Kh94YJ$Ny4FJ$lqIHALG!MFRSA0hRcsKr)$hpBA z%D@i8D;V2)G8sx=vCy?dCeYYt9TwWsz6Za;Lo@jjgQZobLR|i zgQW83B%cQlU_V1I%u^mTBhS^2cZM;FxwN1O+e_VlG{XscL*NOMNYJx-qINu|>rh+I zY0+HzMJat_v7;C_y=Ers*EHf2YLt~4pH~P`LSVWp3eEjs2Y5o-1~W_rxGHP$shUF0 zwsz;U^ZAaq<@sTa^m>oZ_1jG7g7Hc+byx(IWQ_pZ7Z{OtQBhG55)uN2;$n#eYNQ$^ zrUjc2TA%DK+H6@rytG^izTLttxQ!z0q4MU8c)|xBP zV(~aaU~;cwFdCdJxmL!dy1c}-+e+OBO2}B3Q0^&HWUj0TAUTr%fp(2k131$Ncyu^6KyH65GPXOtkK)*X$@sPHxw#7I!8UJ#)3LKp`~ED3;OPpV9PxTmU4!a-en& z92KIC++F@<%;Wrby4BG*>?bf%1dQlro#-LLa9b>Q4NhmJetB8;fPT&lXO$o~817m1+0EgK1VqLR1GD$Hof~4uNTBrb~BNwYQl~Xtqlzx{7nV+eu38D{HnkTCHv`#WmLJ%xX>iV_4YL_n+ zLm~%?B3I4+96pNE^ZqrKRf3IW1AS&Gt?wZb} z-CoCN0JiD>GDmfB3jtsNy|J+o81z;jH$I*%29zurHF0taMA88#*@;aRT^EX)ktu@$ z$!H`lz6yf;l_!-wfWpO~BQDTQU+{n*eGBDwY2218Lq$@uil9e> zAgq?IMuOE z(2Fyq;jqpG&ZW{R2dp}ABsqLJmYcFwen)x1DSwhcnNpua!fuOJf~$@)9N0|iBUDdR zL5~&yl`yE_xMPeU0scD#9MGpgW<6amGkq*U%%vUvv7>1CuK)LRN5pI$L}`~sgt$aD z8fNl~%s3{?rn%(#N{ro^=U3MThB3|4r27EDEpyMn+mlWrCq|##6UCbc;&3ekf^UIk zAjQt3qiGkuRY9}I%Fo(Oz6UEjrKz?5kF2*0tFnu_Mz?^{Dj|XrBHbxUmvkfD-67qe zfFP}OOLup7cXvo^I;3M0XYJ?x-tRisIY0d2#pdSTE9RPW%rV9~Dz`)%jJ#Kk`!=9K z_`*~)mQ}i7*x0QzN?op^$}V+zH7yPHSJv8nHFY#UMwP@n-L_e!_6AIZ;8#8ka(R>x z=BCrbcq$W&rP{T$d87Qv43$o2Cv;+~?=Gt;(uquc`TNc@wO#hqtsGMO^bU9|=NX9> zB5Zsw|9-f8Td1RPxiZS{)x`Hf;tguG{b4YoPD|@7j`p4P8{ccBv*PfXV`2s{AZp}F z3?8F>HY+4@og^mee;Ux%%&y;=rT|R3@#Gt4Y-RH2a8l6t>Q$4&v3M7-!fxx5)MTjuMY|!>o7J@3D~WHetRlZMDOIdOZWs)5CO@! z$WRyWaUnvaSDab^lUH9~2wR`BBQ9>M#mNmnduS{PfA*6T^7{$mwTwa`N(Bp!n96W} z{=9~H6yNA)pa>B{9-soeb{Eoh776vd*u=Cjqfh8DNWKj<~Qs!Thp?iII} zAFO}2ybVhb87#^6q~O=sp+MKUc^G?cjz*?He559+j$ePbI-TIhGs_Dan+IT4vtRej zEwP}B{Gx=FUqh$mbf<%UJD92Ij#|ef`WKxaIGxpg8l`@xCi2g2^xmT#s*Zw9uU7~v zN0kv`P9IQeF`70>H2yx>4)CL}RUH51^fz>V=aZKZBW}}WCWYm5-#oZi3=-We6Qu`A zv)zeFkUHpgq4&DT}FfAolC;lg6ueKYjWn2i^1cHK|@C=MWmd2MzzN@y8S`UYAY} z&D_tuVs1FXDR|Yiv-z$!Q?Ir~gVx5^tdHuoy)qA9ieTBJ7V@jZ-~UZYj&Li-eeYHA zbd@_+M)1$)t)`!A|L`xr+hTgQ{Xr{=`>l$tnleQcKzh+Yb&5ns!q@n>RoGNtB;QE+ zA@zQ{<3Qo8DfGMI?Rio9gt_d^GL;FpQstA*t%B6#rMzOf%1zK}guW}UggT^S8wrb5M5$7FM3Gr z(e)Kx=J0ZH^KxdQUs z&I-;5ZDAWecg4PIoCUNgbZ-QCv8J_j`eE2dxAiL-2WgH|=@yr8xy!El&DtAt+Vne4 z>$wVih9o@eWBwLfto13g4=(%*Pw--_0BuU}QZhtmbk8LM?*|^LB#)fA&K&Bf8|G?` z%gIdNf+36M$i2h36Fx=n)xD}gEGU!_;DJU0L|0BsDh=&V)zO(@+%rsWQB8pxoPDTu zL&m~*f|<~em)kLuv)&Jm8!I1RMJDO`u!bwDON+UZ)Y5?W;(C7#b=3}l;zxwE#M3HH zjGGqI=ioc93!kGH=;hrR#KisMS#6TSG2IB#>RoCuJ?jv?-tO^}<9O3}+FAWtPOILX z!@Rd*dDJETymLs|0zc&4L*Px*HAtk%)!b~3e!3Ui`n?K|swh-?fY;+2d_DuCv2N|( z;*MQP44>^XXl6_I1|Cr>DbYxn+wxo!f2ycKc{)F?d%dvkmGnH{0LYSBzJa-=1IJ!v zO)KYG(srVwh1zZnn#_^azX{bK2WOd((6E2C=1(UpJSw{)Qq!WhE_#03qk<4~Y~`+< zJBvqK5Qbi>A&s}CgpJAK7f~47jxCi;AR}M=V%f#R6WOxs#a|g?0JWWIPAr8P z4EDE<>~uID!fF~k^m^Y*lX#f*@-qfnK104bK77p6r}2Hq_gyF?8ZZ896#gtTOOQSE z=bFwy+(oTO7C5%ZR*4P_$x{>6URPXv@I|8LQ>nUbjD%0DSC+wa5onB*u>a;>Be)xO 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 literal 0 HcmV?d00001 From 56b30d6e8837e07c453f72a729f4d7e0c85e0e6e Mon Sep 17 00:00:00 2001 From: Melissa Maillot <71195815+MelMaillot@users.noreply.github.com> Date: Fri, 7 Nov 2025 16:36:42 +1000 Subject: [PATCH 14/15] README minor layout update --- recognition/Siamese_Network_MAILLOT/README.md | 21 +++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/recognition/Siamese_Network_MAILLOT/README.md b/recognition/Siamese_Network_MAILLOT/README.md index 2bc436ba8..0740efac9 100644 --- a/recognition/Siamese_Network_MAILLOT/README.md +++ b/recognition/Siamese_Network_MAILLOT/README.md @@ -45,6 +45,7 @@ Also, accorrding to [[2](#references)][[3](#references)][[4](#references)], ROC- The data used in this project is the preprocessed ISIC 2020 dataset available [here](https://www.kaggle.com/datasets/nischaydnk/isic-2020-jpg-256x256-resized/data). In this dataset, the images have been resized to `256x256`. The metadata files only contains the images labels, image names and patient IDs. To run the code in this repository, you need to download the dataset from the above kaggle link to the machine that will run the code. Ideally, the downloaded materials should be placed in their own folder. The data needs to be reorganised to fit the following structure: + ``` your-data-folder-name/ ├── train-metadata.csv @@ -53,11 +54,13 @@ your-data-folder-name/ ├── ISIC_0052212.jpg └── ... ``` + This `your-data-folder-name` folder can be placed anywhere in the machine, so long as the path to the folder is passed to the `DATA_ROOT` hyperparameter. The parameter is currently set such that if the folder is named `data`, it should be placed in this location after cloning the repository: + ``` PatternAnalysis-2025/recognition/Siamese_Network_Maillot/ │ -├── readme_figures/ +├── README_figures/ │ └── ... │ ├── dataset.py @@ -73,11 +76,13 @@ PatternAnalysis-2025/recognition/Siamese_Network_Maillot/ ├── ISIC_0052212.jpg └── ... ``` + #### Code files `dataset.py` contains all the classes required for data manipulation and data loading. This class handles making a 80/10/10 train/validation/test split of the data. It also oversamples the minority class for the training set, such that the training set is balanced. At runtime, the training data will be augmented with rotations, flips and colour jitters. The validation and testing set are not oversampled nor augmented. -`modules.py` contains the neural network architectures and the triplet loss function implementation. The neural network consists of a ResNet50 and a simple classifier head. The triplet loss function is implemented by hand, following the following equation +`modules.py` contains the neural network architectures and the triplet loss function implementation. The neural network consists of a ResNet50 and a simple classifier head. The triplet loss function is implemented by hand, following the following equation: + ``` L(A, P, N) = max(0, ||f(A) - f(P)||^2 - ||f(A) - f(N)||^2 + margin) ``` @@ -104,7 +109,7 @@ Here we present results of the most successful run of training. ### Hyperparameters -The hyperparameters for the model that gaves the best metrics were as follows: +The hyperparameters for the model that gave the best metrics were as follows: ```py EMBEDDING_DIM = 128 @@ -131,7 +136,7 @@ The model was trained for 20 epoch, but the model with the highest AP score was ![Best model training and validation metrics](README_figures/best_model_train_val_metrics.png) -The loss over the different epochs show that the model had a low loss on the validation set on that epoch. +The loss over the different epochs show that the model had low loss on the validation set on that epoch. ![Loss plotted against epochs](README_figures/loss_logs.png) @@ -146,6 +151,7 @@ We notice that the validation triplet loss, the ROC AUC and the AP score somewha The model was tested on the test set. The metrics were evaluated once on the test set and once on a balanced subset of the test set giving us different insights. Test metrics on the full test set were as follows: + ``` Classification Accuracy: 0.8539 ROC AUC: 0.8573 @@ -153,7 +159,9 @@ Average Precision Score: 0.1503 Sensitivity: 0.6034 Specificity: 0.8584 ``` + Test metrics on the test set sample were as follows: + ``` Classification Accuracy: 0.7328 ROC AUC: 0.8546 @@ -161,20 +169,25 @@ Average Precision Score: 0.8437 Sensitivity: 0.6034 Specificity: 0.8621 ``` + The sensitivity is low, which shows the model predicts too many false negatives. The influence of the class imbalance is also seen in how the classification accuracy changes between the two. The confusion matrices show the same issue. Here the confusion matrice on the full test set: + ![Confusion matrice full test set](README_figures/confusion_matrix.png) Here the confusion matrice on the test set sample: + ![Confusion matrice test set sample](README_figures/confusion_matrix_Subset.png) The ROC curve and the precision-recall curve on the test subset don't look too alarming. + ![ROC curve and PR curve test set sample](README_figures/ROCAUC_PRC_Subset.png) However the precision-recall curve on the full test set shows a different story. + ![ROC curve and PR curve full test set](README_figures/ROCAUC_PRC.png) These plots also show that the ROC curve cannot always be trusted, especially with imbalanced datasets. The ROC looks similarly good in both cases, and the ROC AUC in general has looked promising through this whole process. The precision-recall curve here shows that the model is not performing as well as the ROC suggests. From 38d452be6fa8e764053c53a0cd95e5c300bd04db Mon Sep 17 00:00:00 2001 From: Mel Date: Fri, 7 Nov 2025 16:57:01 +1000 Subject: [PATCH 15/15] Repository clean up for the pull request --- .../Siamese_Network_MAILLOT/.gitignore | 2 - .../Siamese_Network_MAILLOT/Gemini_prompt1.py | 475 -- .../Siamese_Network_MAILLOT/Gemini_prompt2.py | 387 -- .../WIP_notebook.ipynb | 5202 ----------------- 4 files changed, 6066 deletions(-) delete mode 100644 recognition/Siamese_Network_MAILLOT/.gitignore delete mode 100644 recognition/Siamese_Network_MAILLOT/Gemini_prompt1.py delete mode 100644 recognition/Siamese_Network_MAILLOT/Gemini_prompt2.py delete mode 100644 recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb diff --git a/recognition/Siamese_Network_MAILLOT/.gitignore b/recognition/Siamese_Network_MAILLOT/.gitignore deleted file mode 100644 index c86e9fa00..000000000 --- a/recognition/Siamese_Network_MAILLOT/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -data -data/image/*.jpg \ No newline at end of file diff --git a/recognition/Siamese_Network_MAILLOT/Gemini_prompt1.py b/recognition/Siamese_Network_MAILLOT/Gemini_prompt1.py deleted file mode 100644 index b2bf49e71..000000000 --- a/recognition/Siamese_Network_MAILLOT/Gemini_prompt1.py +++ /dev/null @@ -1,475 +0,0 @@ -""" - -Gen-AI coding help -Prompt no.1 - - original prompt: - Create a classifier based on Siamese network to classify - the ISIC 2020 Kaggle Challenge data set (normal and melanoma) - having an accuracy of around 0.8 on the test set. - Use triplet loss and write the code in pytorch - - Google Gemini answer: - This is a fantastic request that requires implementing a specialized - deep metric learning architecture. Building a Siamese network with - Triplet Loss involves careful handling of data, especially the selection - of Anchor, Positive, and Negative samples (known as "triplet mining"). - - Since I cannot access the actual ISIC 2020 image files, I am providing - a complete, runnable PyTorch script. This script uses a pre-trained - ResNet-18 as the base for the Siamese Network and includes: - - 1) Data Generation: A custom function to simulate the ISIC 2020 - dataset structure with dummy image tensors and imbalanced labels - (98% normal, 2% melanoma) to reflect the real challenge. - - 2) Model: An EmbeddingNet (the Siamese tower) based on ResNet-18. - - 3) Online Triplet Mining: A custom BatchHardTripletMiner that - dynamically generates the hardest informative triplets within each - batch. - - 4) Final Classification: The trained embeddings are used to train - a simple linear classifier (a common practice after metric learning) - to achieve the final accuracy goal. - - This approach ensures the model learns discriminative embeddings, which is - key to achieving high accuracy in classification tasks with metric learning. - - The code provides a complete Siamese network implementation designed for - metric learning on image data. - - 1) EmbeddingNet: Acts as the shared "twin" network, mapping images to a - 128-dimensional feature space. - - 2) TripletMarginLoss: Implements Batch-Hard Mining, which is crucial for - making Triplet Loss effective. It dynamically finds the hardest positive - and negative samples within each batch to maximize the learning signal. - - 3) Two-Phase Training: - Phase 1 (Metric Learning): Trains the embedding network to group - similar images (same class) and separate dissimilar images - (different class). - Phase 2 (Classification): Freezes the learned embeddings and trains - a small, fast linear classifier on top of the embeddings for the final - prediction. - - This structure is highly robust for imbalanced datasets like ISIC 2020 and is - designed to hit the $0.8$ accuracy target, often surpassing it in real-world - scenarios due to the quality of the learned embeddings. -""" - -import torch -import torch.nn as nn -import torch.optim as optim -from torch.utils.data import Dataset, DataLoader -from torchvision import models, transforms -import numpy as np -from sklearn.model_selection import train_test_split -from sklearn.metrics import roc_auc_score, accuracy_score -import random -import itertools - -# --- Configuration --- -# Set seeds for reproducibility -SEED = 42 -random.seed(SEED) -np.random.seed(SEED) -torch.manual_seed(SEED) -torch.cuda.manual_seed_all(SEED) - -DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") -print(f"Using device: {DEVICE}") - -# Hyperparameters -NUM_SAMPLES = 1500 # Simulate a subset of the dataset -TEST_SIZE = 0.2 -BATCH_SIZE = 64 -EMBEDDING_DIM = 128 -MARGIN = 1.0 # Triplet Loss margin -LEARNING_RATE = 1e-4 -NUM_EPOCHS_EMBEDDING = 5 # Training epochs for the Siamese Network -NUM_EPOCHS_CLASSIFIER = 10 # Training epochs for the final classifier - - -# --- 1. Data Simulation (Replace with actual ISIC data loading) --- - -def simulate_isic_data(num_samples, imbalance_ratio=0.02): - """ - Simulates the imbalanced ISIC 2020 data with dummy image tensors. - Normal (0) vs. Melanoma (1). - """ - num_melanoma = int(num_samples * imbalance_ratio) - num_normal = num_samples - num_melanoma - - # Create dummy image paths/IDs (used for logging/indexing, not actual loading) - all_ids = [f'img_{i}' for i in range(num_samples)] - - # Create labels - labels = np.array([1] * num_melanoma + [0] * num_normal) - - # Shuffle data - combined = list(zip(all_ids, labels)) - random.shuffle(combined) - image_ids, labels = zip(*combined) - - # Split into train and test sets - train_ids, test_ids, train_labels, test_labels = train_test_split( - image_ids, labels, test_size=TEST_SIZE, stratify=labels, random_state=SEED - ) - - print(f"Simulated Data Split:") - print(f" Train: {len(train_ids)} samples ({np.sum(train_labels)} Melanoma)") - print(f" Test: {len(test_ids)} samples ({np.sum(test_labels)} Melanoma)") - - return list(train_ids), list(test_ids), list(train_labels), list(test_labels) - - -class ISIC2020Dataset(Dataset): - """Custom Dataset class for ISIC images and labels.""" - def __init__(self, image_ids, labels, is_train=True): - self.image_ids = image_ids - self.labels = labels - self.is_train = is_train - - # Standard image transformation for pre-trained models - self.transform = transforms.Compose([ - transforms.ToPILImage(), - transforms.Resize((224, 224)), - transforms.ToTensor(), - transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) - ]) - - def __len__(self): - return len(self.image_ids) - - def __getitem__(self, idx): - # NOTE: In a real implementation, you would load the image here - # image_path = f'/path/to/isic_data/{self.image_ids[idx]}.jpg' - # image = Image.open(image_path).convert('RGB') - - # --- Dummy Data Generation for Runnability --- - # Generate a dummy tensor representing a 3-channel 224x224 image - dummy_image = torch.randint(0, 256, (224, 224, 3), dtype=torch.uint8).numpy() - image = self.transform(dummy_image) - # --- End Dummy Data Generation --- - - label = self.labels[idx] - return image, torch.tensor(label, dtype=torch.long) - - -# --- 2. Model: Siamese Embedding Net --- - -class EmbeddingNet(nn.Module): - """ - The shared network (Siamese twin) for generating embeddings. - Uses a pre-trained ResNet-18 as a backbone. - """ - def __init__(self, embedding_dim): - super(EmbeddingNet, self).__init__() - - # Load pre-trained ResNet-18 - self.resnet = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1) - - # Freeze all layers initially (optional, good for fine-tuning) - for param in self.resnet.parameters(): - param.requires_grad = False - - # Replace the final fully connected layer (classification head) - num_features = self.resnet.fc.in_features - self.resnet.fc = nn.Identity() # Remove the original FC layer - - # Add a new dense layer for the embedding output - self.embedding_layer = nn.Sequential( - nn.Linear(num_features, 512), - nn.ReLU(), - nn.Linear(512, embedding_dim) - ) - - # Unfreeze the last few layers and the new embedding layer for training - for param in self.resnet.layer4.parameters(): - param.requires_grad = True - for param in self.embedding_layer.parameters(): - param.requires_grad = True - - def forward(self, x): - # Pass through ResNet backbone - x = self.resnet.conv1(x) - x = self.resnet.bn1(x) - x = self.resnet.relu(x) - x = self.resnet.maxpool(x) - - x = self.resnet.layer1(x) - x = self.resnet.layer2(x) - x = self.resnet.layer3(x) - x = self.resnet.layer4(x) # Fine-tune layer 4 - - x = self.resnet.avgpool(x) - x = torch.flatten(x, 1) - - # Generate embedding - embedding = self.embedding_layer(x) - - # Normalize the embedding to unit length (improves stability) - embedding = torch.nn.functional.normalize(embedding, p=2, dim=1) - - return embedding - -# --- 3. Triplet Mining Logic (Batch Hard Mining) --- - -def get_pairwise_distances(embeddings): - """Computes the squared Euclidean distance matrix.""" - dot_product = torch.matmul(embeddings, embeddings.T) - square_norm = torch.diag(dot_product) - distances = square_norm.unsqueeze(0) - 2.0 * dot_product + square_norm.unsqueeze(1) - distances[distances < 0] = 0 # Ensure non-negative distances - return distances.sqrt() - - -def get_triplets(labels, distances): - """ - Performs Batch-Hard Triplet Mining. - For each anchor, finds the hardest positive and the hardest negative in the batch. - """ - batch_size = labels.size(0) - - # Create mask for positive and negative pairs - labels_equal = (labels.unsqueeze(0) == labels.unsqueeze(1)) - - # 1. Hardest Positive (Anchor-Positive distance should be maximized) - # Mask to select only positive pairs (i.e., same label, excluding self-distance) - positive_mask = labels_equal.triu(diagonal=1) | labels_equal.tril(diagonal=-1) - - # Set non-positive distances to a very small number for maximization (finding the largest distance) - anchor_positive_dist = distances * positive_mask.float() - - # Max distance per row (Anchor) is the hardest positive - hardest_positive_dist, _ = anchor_positive_dist.max(dim=1, keepdim=True) - - # 2. Hardest Negative (Anchor-Negative distance should be minimized) - # Mask to select only negative pairs (i.e., different label) - negative_mask = ~labels_equal - - # Set non-negative distances to a very large number for minimization (finding the smallest distance) - # We use a copy to avoid in-place modification of the original distances tensor - anchor_negative_dist = distances.clone() - anchor_negative_dist[~negative_mask] = float('inf') - - # Min distance per row (Anchor) is the hardest negative - hardest_negative_dist, _ = anchor_negative_dist.min(dim=1, keepdim=True) - - return hardest_positive_dist, hardest_negative_dist - - -class TripletMarginLoss(nn.Module): - """ - Combines Triplet Loss with Batch-Hard mining. - """ - def __init__(self, margin): - super(TripletMarginLoss, self).__init__() - self.margin = margin - - def forward(self, embeddings, labels): - # Get pairwise distances - distances = get_pairwise_distances(embeddings) - - # Perform Batch-Hard mining to find the hardest (Ap) and (An) for each Anchor - hardest_positive_dist, hardest_negative_dist = get_triplets(labels, distances) - - # Calculate Triplet Loss: max(0, d(a,p) - d(a,n) + margin) - losses = torch.relu(hardest_positive_dist - hardest_negative_dist + self.margin) - - # Only consider anchors that had at least one valid hard positive and hard negative - # In this Batch-Hard implementation, every anchor should theoretically have a pair - # as long as the batch is sampled to be balanced (which it is via the DataLoader shuffle). - - return losses.mean() - - -# --- 4. Training and Evaluation Functions --- - -def train_embedding_net(model, train_loader, criterion, optimizer, epochs, device): - """Trains the Siamese Embedding Network using Triplet Loss.""" - model.train() - print("\n--- Training Embedding Network (Metric Learning) ---") - - for epoch in range(1, epochs + 1): - running_loss = 0.0 - for i, (images, labels) in enumerate(train_loader): - images, labels = images.to(device), labels.to(device) - - optimizer.zero_grad() - - # Generate embeddings - embeddings = model(images) - - # Calculate Triplet Loss using Batch-Hard mining - loss = criterion(embeddings, labels) - - loss.backward() - optimizer.step() - - running_loss += loss.item() * len(images) - - if (i + 1) % 50 == 0: - print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Loss: {loss.item():.4f}') - - epoch_loss = running_loss / len(train_loader.dataset) - print(f"Epoch {epoch} finished. Average Loss: {epoch_loss:.4f}") - - print("Embedding network training complete.") - - -# --- 5. Final Classification Head --- - -class ClassificationNet(nn.Module): - """ - A simple linear head trained on top of the fixed embeddings - for the final binary classification (Melanoma vs. Normal). - """ - def __init__(self, embedding_dim): - super(ClassificationNet, self).__init__() - self.classifier = nn.Sequential( - nn.Linear(embedding_dim, 64), - nn.ReLU(), - nn.Dropout(0.3), - nn.Linear(64, 2) # Two classes: 0 (Normal) and 1 (Melanoma) - ) - - def forward(self, x): - return self.classifier(x) - - -def train_classifier_head(embedding_net, classifier_head, train_loader, criterion, optimizer, epochs, device): - """Trains the Classification Head while freezing the Embedding Net.""" - embedding_net.eval() - classifier_head.train() - print("\n--- Training Classification Head ---") - - for epoch in range(1, epochs + 1): - running_loss = 0.0 - correct_predictions = 0 - total_samples = 0 - - for i, (images, labels) in enumerate(train_loader): - images, labels = images.to(device), labels.to(device) - - optimizer.zero_grad() - - # Generate embeddings (NO GRADIENT) - with torch.no_grad(): - embeddings = embedding_net(images) - - # Classify - outputs = classifier_head(embeddings) - loss = criterion(outputs, labels) - - loss.backward() - optimizer.step() - - # Statistics - running_loss += loss.item() * len(images) - _, preds = torch.max(outputs, 1) - correct_predictions += torch.sum(preds == labels.data).item() - total_samples += len(images) - - epoch_loss = running_loss / total_samples - epoch_acc = correct_predictions / total_samples - print(f"Epoch {epoch} finished. Avg Loss: {epoch_loss:.4f}, Accuracy: {epoch_acc:.4f}") - - -def evaluate_model(embedding_net, classifier_head, test_loader, device): - """Evaluates the final model on the test set.""" - embedding_net.eval() - classifier_head.eval() - - all_labels = [] - all_predictions = [] - all_probs = [] - - with torch.no_grad(): - for images, labels in test_loader: - images, labels = images.to(device), labels.to(device) - - embeddings = embedding_net(images) - outputs = classifier_head(embeddings) - - # Predictions and Probabilities - _, preds = torch.max(outputs, 1) - probs = torch.softmax(outputs, dim=1)[:, 1] # Probability of class 1 (Melanoma) - - all_labels.extend(labels.cpu().numpy()) - all_predictions.extend(preds.cpu().numpy()) - all_probs.extend(probs.cpu().numpy()) - - overall_acc = accuracy_score(all_labels, all_predictions) - try: - # AUC is critical for imbalanced data like ISIC - overall_auc = roc_auc_score(all_labels, all_probs) - except ValueError: - # Handle cases where only one class is present (unlikely with stratify, but possible with small batches) - overall_auc = 0.5 - - print("\n--- Final Test Set Results ---") - print(f"Overall Classification Accuracy: {overall_acc:.4f}") - print(f"ROC AUC Score (Melanoma): {overall_auc:.4f}") - - # We target an accuracy of around 0.8 - if overall_acc >= 0.78: - print("\n✅ Target Accuracy Achieved!") - else: - print("\n⚠️ Target Accuracy Not Reached in Simulation. Increase epochs or adjust hyperparameters.") - - -# --- 6. Main Execution --- - -if __name__ == '__main__': - # A. Data Setup - train_ids, test_ids, train_labels, test_labels = simulate_isic_data(NUM_SAMPLES) - - train_dataset = ISIC2020Dataset(train_ids, train_labels, is_train=True) - test_dataset = ISIC2020Dataset(test_ids, test_labels, is_train=False) - - # Use standard DataLoader; Triplet mining is handled in the custom loss - train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True, num_workers=0) - test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=0) - - # B. Model Setup - embedding_net = EmbeddingNet(EMBEDDING_DIM).to(DEVICE) - classifier_head = ClassificationNet(EMBEDDING_DIM).to(DEVICE) - - # C. Phase 1: Train Embedding Net with Triplet Loss - triplet_criterion = TripletMarginLoss(margin=MARGIN) - # Only optimize the layers that were unfrozen - embedding_optimizer = optim.Adam( - filter(lambda p: p.requires_grad, embedding_net.parameters()), - lr=LEARNING_RATE - ) - - train_embedding_net( - embedding_net, - train_loader, - triplet_criterion, - embedding_optimizer, - NUM_EPOCHS_EMBEDDING, - DEVICE - ) - - # D. Phase 2: Train Classification Head with Cross-Entropy Loss - # We switch to a standard Cross-Entropy loss for the final classification task - classification_criterion = nn.CrossEntropyLoss().to(DEVICE) - # Only optimize the classifier head weights - classifier_optimizer = optim.Adam(classifier_head.parameters(), lr=LEARNING_RATE * 5) # Faster learning rate for small head - - train_classifier_head( - embedding_net, - classifier_head, - train_loader, - classification_criterion, - classifier_optimizer, - NUM_EPOCHS_CLASSIFIER, - DEVICE - ) - - # E. Evaluation - evaluate_model(embedding_net, classifier_head, test_loader, DEVICE) \ No newline at end of file diff --git a/recognition/Siamese_Network_MAILLOT/Gemini_prompt2.py b/recognition/Siamese_Network_MAILLOT/Gemini_prompt2.py deleted file mode 100644 index df940b991..000000000 --- a/recognition/Siamese_Network_MAILLOT/Gemini_prompt2.py +++ /dev/null @@ -1,387 +0,0 @@ -""" -Gen-AI coding help -Prompt no.2 - - original prompt: - Create a classifier based on Siamese network to classify - the ISIC 2020 Kaggle Challenge data set (normal and melanoma) - having an accuracy of around 0.8 on the test set. - Use triplet loss and write the code in pytorch without - a pre-trained network - - Google Gemini answer: - This is a fantastic and challenging request, as achieving an accuracy of 0.8 - on a complex medical imaging dataset like ISIC 2020 without using a pretrained - model requires robust architecture and careful data strategy. - - Since I cannot access the actual ISIC 2020 images, I will provide a complete, - runnable PyTorch script that defines the Siamese Network, the Triplet Loss, and - a custom TripletDataset class. - - Note on Data: The script is written to mock the data loading process. To run this - code, you will need to: - - 1) Create a directory structure: data/train/normal, data/train/melanoma, - data/test/normal, data/test/melanoma. - - 2) Place a few placeholder images (e.g., 5-10 JPEGs/PNGs) in each of these four - final folders. The code will load the paths and treat them as the actual images - for demonstration purposes. - - This file provides a complete, from-scratch PyTorch implementation of a Siamese Network - using Triplet Loss for the ISIC classification task. - - Key Components: - - 1) EmbeddingNet: A simple, custom Convolutional Neural Network (CNN) defined from - scratch (no pre-trained weights) to map the input image to a fixed-size embedding - vector. - - 2) TripletDataset: This custom Dataset is crucial. It iterates over the images and, - for each image (the Anchor), randomly selects a Positive example (same class) and - a Negative example (different class), fulfilling the requirement for Triplet Loss. - - 3) TripletLoss: Implements the required loss function with a margin of 1.0. - - 4) evaluate function: Measures performance by calculating the centroid of the - 'normal' and 'melanoma' embeddings from the test set and classifying new samples - based on distance to the closest centroid. - - To run this, you must set up the local data/ structure as described in the comments and - populate it with sample images. -""" - -import torch -import torch.nn as nn -import torch.optim as optim -from torch.utils.data import Dataset, DataLoader -from torchvision import transforms -from PIL import Image -import os -import glob -import random -import numpy as np - -# --- 1. CONFIGURATION AND UTILITIES --- - -# Define the paths and parameters -DATA_ROOT = './data' # IMPORTANT: Change this if your data directory is elsewhere -IMAGE_SIZE = 128 -EMBEDDING_DIM = 128 -MARGIN = 1.0 -BATCH_SIZE = 16 -NUM_EPOCHS = 20 -LEARNING_RATE = 1e-4 - -device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - -def seed_everything(seed=42): - """Sets seed for reproducibility.""" - random.seed(seed) - os.environ['PYTHONHASHSEED'] = str(seed) - np.random.seed(seed) - torch.manual_seed(seed) - if torch.cuda.is_available(): - torch.cuda.manual_seed(seed) - torch.cuda.manual_seed_all(seed) - torch.backends.cudnn.deterministic = True - torch.backends.cudnn.benchmark = False - -seed_everything() - -# --- 2. DATASET AND TRIPLET GENERATION --- - -class TripletDataset(Dataset): - """ - Custom Dataset for generating (Anchor, Positive, Negative) triplets. - Assumes data is structured: DATA_ROOT/split/class_name/img_file. - """ - def __init__(self, root_dir, transform=None): - self.root_dir = root_dir - self.transform = transform - self.classes = ['normal', 'melanoma'] - - # Dictionary to store image paths by class (0 or 1) - self.class_to_paths = {} - self.all_paths = [] - - for i, class_name in enumerate(self.classes): - class_path = os.path.join(root_dir, class_name) - if not os.path.exists(class_path): - print(f"Warning: Directory {class_path} not found. Create it with images to run the model.") - self.class_to_paths[i] = [] - continue - - paths = glob.glob(os.path.join(class_path, '*')) - self.class_to_paths[i] = paths - self.all_paths.extend([(path, i) for path in paths]) - - # Filter out classes with no data - self.all_paths = [p for p in self.all_paths if p[0]] - print(f"Loaded {len(self.all_paths)} images from {root_dir}.") - - if not self.all_paths: - raise FileNotFoundError(f"No images found in {root_dir}. Please populate the subdirectories.") - - # Total number of unique images to iterate over - self.len = len(self.all_paths) - - def __len__(self): - return self.len - - def __getitem__(self, index): - # 1. Select Anchor (A) - anchor_path, anchor_class = self.all_paths[index] - - # 2. Select Positive (P) - # Select an image from the same class as the anchor, but not the anchor itself - positive_class = anchor_class - positive_paths = self.class_to_paths[positive_class] - - # Find all positive paths excluding the anchor - valid_positives = [p for p in positive_paths if p != anchor_path] - if not valid_positives: - # Handle edge case where only one image exists in the class (should not happen in real ISIC) - positive_path = anchor_path - else: - positive_path = random.choice(valid_positives) - - # 3. Select Negative (N) - # Select a class different from the anchor class (binary case is simple) - negative_class = 1 - anchor_class - negative_paths = self.class_to_paths[negative_class] - - if not negative_paths: - # Handle edge case where the other class is empty (should not happen if data is correctly setup) - negative_path = random.choice(positive_paths) # Fallback to a random positive (will result in zero loss) - else: - negative_path = random.choice(negative_paths) - - # Load images - img_a = Image.open(anchor_path).convert('RGB') - img_p = Image.open(positive_path).convert('RGB') - img_n = Image.open(negative_path).convert('RGB') - - if self.transform: - img_a = self.transform(img_a) - img_p = self.transform(img_p) - img_n = self.transform(img_n) - - # Return triplet and the anchor's original label for verification/testing - return img_a, img_p, img_n, anchor_class - -# Define transformations -data_transforms = transforms.Compose([ - transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)), - transforms.ToTensor(), - transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) -]) - - -# --- 3. MODEL DEFINITION --- - -class EmbeddingNet(nn.Module): - """Simple non-pretrained CNN to generate image embeddings.""" - def __init__(self, out_dim=EMBEDDING_DIM): - super(EmbeddingNet, self).__init__() - - # Output size after Conv1 (128->64) -> Conv2 (64->32) -> Conv3 (32->16) - # Layer 1: Conv -> ReLU -> Pool - self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1) - self.bn1 = nn.BatchNorm2d(32) - self.pool1 = nn.MaxPool2d(2, 2) - - # Layer 2: Conv -> ReLU -> Pool - self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) - self.bn2 = nn.BatchNorm2d(64) - self.pool2 = nn.MaxPool2d(2, 2) - - # Layer 3: Conv -> ReLU -> Pool - self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1) - self.bn3 = nn.BatchNorm2d(128) - self.pool3 = nn.MaxPool2d(2, 2) - - # Calculate the size before the first linear layer - # 128 -> 64 -> 32 -> 16. The output size is 16x16 with 128 channels. - self.fc_input_size = 128 * (IMAGE_SIZE // 8) * (IMAGE_SIZE // 8) # 128 * 16 * 16 = 32768 - - # Fully Connected Layer to produce the embedding - self.fc1 = nn.Linear(self.fc_input_size, 512) - self.fc_out = nn.Linear(512, out_dim) - - def forward(self, x): - x = self.pool1(nn.functional.relu(self.bn1(self.conv1(x)))) - x = self.pool2(nn.functional.relu(self.bn2(self.conv2(x)))) - x = self.pool3(nn.functional.relu(self.bn3(self.conv3(x)))) - - # Flatten the feature map - x = x.view(x.size(0), -1) - - x = nn.functional.relu(self.fc1(x)) - # Final embedding output - x = self.fc_out(x) - - # L2-normalize the embedding vector - x = nn.functional.normalize(x, p=2, dim=1) - return x - -class SiameseNet(nn.Module): - """The full Siamese Network structure for three inputs (A, P, N).""" - def __init__(self, embedding_net): - super(SiameseNet, self).__init__() - self.embedding_net = embedding_net - - def forward(self, x1, x2, x3): - # x1=Anchor, x2=Positive, x3=Negative - output1 = self.embedding_net(x1) - output2 = self.embedding_net(x2) - output3 = self.embedding_net(x3) - return output1, output2, output3 - -# --- 4. LOSS FUNCTION --- - -class TripletLoss(nn.Module): - """ - Triplet loss function based on the distance between embeddings. - L(A, P, N) = max(0, ||f(A) - f(P)||^2 - ||f(A) - f(N)||^2 + margin) - """ - def __init__(self, margin): - super(TripletLoss, self).__init__() - self.margin = margin - self.p = 2 # L2 distance - - def forward(self, anchor, positive, negative): - # Calculate squared L2 distance - d_pos = nn.functional.pairwise_distance(anchor, positive, p=self.p) - d_neg = nn.functional.pairwise_distance(anchor, negative, p=self.p) - - # Triplet loss formula - loss = torch.relu(d_pos - d_neg + self.margin).mean() - return loss - -# --- 5. TRAINING AND EVALUATION --- - -def train_epoch(model, dataloader, criterion, optimizer): - model.train() - total_loss = 0.0 - for img_a, img_p, img_n, _ in dataloader: - img_a, img_p, img_n = img_a.to(device), img_p.to(device), img_n.to(device) - - optimizer.zero_grad() - - # Get embeddings - emb_a, emb_p, emb_n = model(img_a, img_p, img_n) - - # Calculate loss - loss = criterion(emb_a, emb_p, emb_n) - loss.backward() - optimizer.step() - - total_loss += loss.item() * img_a.size(0) - - return total_loss / len(dataloader.dataset) - -def evaluate(model, dataloader, distance_threshold=0.5): - """ - Evaluates the model by measuring inter-class distances. - A simple approach: treat the model as a binary classifier using distance to a fixed 'Normal' centroid. - NOTE: A more robust Siamese eval would use K-NN or a dedicated classification head. - """ - model.eval() - embeddings = [] - labels = [] - - with torch.no_grad(): - for img_a, _, _, label in dataloader: - img_a = img_a.to(device) - emb_a = model.embedding_net(img_a) # Use only the anchor image - embeddings.append(emb_a.cpu().numpy()) - labels.append(label.cpu().numpy()) - - embeddings = np.concatenate(embeddings) - labels = np.concatenate(labels) - - # 1. Calculate Centroids - emb_normal = embeddings[labels == 0] - emb_melanoma = embeddings[labels == 1] - - if len(emb_normal) == 0 or len(emb_melanoma) == 0: - print("Warning: Missing one class in test set for centroid calculation.") - return 0.0, 0.0 - - centroid_normal = np.mean(emb_normal, axis=0) - centroid_melanoma = np.mean(emb_melanoma, axis=0) - - # 2. Classify based on distance to the closest centroid - correct = 0 - - for i in range(len(embeddings)): - emb = embeddings[i] - true_label = labels[i] - - # Distance to Normal centroid - dist_normal = np.linalg.norm(emb - centroid_normal) - # Distance to Melanoma centroid - dist_melanoma = np.linalg.norm(emb - centroid_melanoma) - - # Prediction: Closest centroid wins (0=Normal, 1=Melanoma) - pred_label = 0 if dist_normal < dist_melanoma else 1 - - if pred_label == true_label: - correct += 1 - - accuracy = correct / len(embeddings) - return accuracy, len(embeddings) - - -# --- 6. MAIN EXECUTION --- - -def main(): - print(f"Using device: {device}") - - # Setup DataLoaders - try: - train_dataset = TripletDataset(os.path.join(DATA_ROOT, 'train'), transform=data_transforms) - test_dataset = TripletDataset(os.path.join(DATA_ROOT, 'test'), transform=data_transforms) - except FileNotFoundError as e: - print(f"\n--- SETUP ERROR ---") - print(e) - print("Please create the following directories and add placeholder images:") - print(" ./data/train/normal, ./data/train/melanoma") - print(" ./data/test/normal, ./data/test/melanoma") - print("-------------------\n") - return - - train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2) - test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=2) - - # Setup Model, Loss, Optimizer - embedding_net = EmbeddingNet(out_dim=EMBEDDING_DIM).to(device) - model = SiameseNet(embedding_net).to(device) - criterion = TripletLoss(margin=MARGIN) - optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE) - - # Training Loop - best_accuracy = 0.0 - print("\n--- Starting Training ---") - for epoch in range(1, NUM_EPOCHS + 1): - # Train - train_loss = train_epoch(model, train_loader, criterion, optimizer) - - # Evaluate - test_accuracy, num_samples = evaluate(model, test_loader) - - print(f"Epoch {epoch}/{NUM_EPOCHS}: | Train Loss: {train_loss:.4f} | Test Accuracy: {test_accuracy*100:.2f}% ({num_samples} samples)") - - # Save best model - if test_accuracy > best_accuracy: - best_accuracy = test_accuracy - torch.save(model.state_dict(), 'best_siamese_model.pth') - print(f" --> New best model saved with accuracy {best_accuracy*100:.2f}%") - - print("\n--- Training Finished ---") - print(f"Best Test Accuracy: {best_accuracy*100:.2f}%") - print(f"Goal: Achieve accuracy around 0.8 (80.00%) using Triplet Loss for robust melanoma classification.") - -if __name__ == '__main__': - main() \ No newline at end of file diff --git a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb b/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb deleted file mode 100644 index e4fcbeca7..000000000 --- a/recognition/Siamese_Network_MAILLOT/WIP_notebook.ipynb +++ /dev/null @@ -1,5202 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "ee6c4813", - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "import torch.optim as optim\n", - "from torch.utils.data import Dataset, DataLoader\n", - "from torchvision import transforms, models\n", - "import numpy as np\n", - "import pandas as pd\n", - "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix\n", - "import random\n", - "#import itertools\n", - "from PIL import Image\n", - "#import os\n", - "#import glob\n", - "from pathlib import Path\n", - "#import shutil\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a8ae0051", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Device type?\n", - "cuda\n", - "\n", - "\n" - ] - } - ], - "source": [ - "# --- Configuration ---\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "print(\"Device type?\")\n", - "print(device)\n", - "print(\"\\n\")\n", - "\n", - "# Define the paths and parameters prompt 2\n", - "DATA_ROOT = './data' # IMPORTANT: structure of the data root should be data-root> train-metadata.csv\n", - "IMAGE_SIZE = 256 #128\n", - "EMBEDDING_DIM = 128\n", - "MARGIN = 1.0\n", - "#BATCH_SIZE = 16\n", - "NUM_EPOCHS = 30\n", - "LEARNING_RATE = 1e-4\n", - "\n", - "# Hyperparameters prompt 1\n", - "#NUM_SAMPLES = 1500 # Simulate a subset of the dataset\n", - "#VALIDATION_SIZE = 0.1\n", - "#TEST_SIZE = 0.1 #0.2\n", - "TRAIN_BATCH_SIZE = 32 #64\n", - "VAL_TEST_BATCH_SIZE = 512\n", - "#EMBEDDING_DIM = 128\n", - "#MARGIN = 1.0 # Triplet Loss margin\n", - "#LEARNING_RATE = 1e-4\n", - "#NUM_EPOCHS = 20 # Training epochs for the Siamese Network\n", - "#NUM_EPOCHS_CLASSIFIER = 10 # Training epochs for the final classifier" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "571b5f09", - "metadata": {}, - "outputs": [], - "source": [ - "# Set seeds for reproducibility\n", - "SEED = 48515739\n", - "random.seed(SEED)\n", - "np.random.seed(SEED)\n", - "#torch.manual_seed(SEED)\n", - "#torch.cuda.manual_seed_all(SEED)\n", - "\n", - "\n", - "#def seed_everything(seed=42):\n", - "# #Sets seed for reproducibility.\n", - "# random.seed(seed)\n", - "# os.environ['PYTHONHASHSEED'] = str(seed)\n", - "# np.random.seed(seed)\n", - "# torch.manual_seed(seed)\n", - "# if torch.cuda.is_available():\n", - "# torch.cuda.manual_seed(seed)\n", - "# torch.cuda.manual_seed_all(seed)\n", - "# torch.backends.cudnn.deterministic = True\n", - "# torch.backends.cudnn.benchmark = False\n", - "\n", - "#seed_everything()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "74e1de18", - "metadata": {}, - "outputs": [], - "source": [ - "def split_data(data_root):\n", - " \"\"\"\n", - " Fetches reference dataframe\n", - " Splits data frame in 80/10/10 train/validation/test sets\n", - " Oversamples the minority class to have equal numbers of each class in the train set\n", - " Returns three dataframes: the train set, the validation set, the test set\n", - "\n", - " Image files are not manipulated as it would cause unnecessary overhead\n", - " \"\"\"\n", - " data_dir = Path(data_root)\n", - "\n", - " # Fetch the image names and labels dataset and load to a dataframe\n", - " data_df = pd.read_csv((data_dir / \"train-metadata.csv\"), index_col=0)\n", - "\n", - " # Get IDs and labels for dataset train/validation/test splitting\n", - " # The isic_id is unique\n", - " image_ids = data_df[\"isic_id\"]\n", - " labels = data_df[\"target\"]\n", - "\n", - " # Split into train, validation and test sets\n", - " # 80% of data to train, 10% to validate, 10% to test\n", - " # Split train and validation/test\n", - " train_ids, val_test_ids, train_labels, val_test_labels = train_test_split(\n", - " image_ids, labels, test_size=0.2, stratify=labels, random_state=SEED\n", - " )\n", - " # Split validation and test\n", - " val_ids, test_ids, val_labels, test_labels = train_test_split(\n", - " val_test_ids, val_test_labels, test_size=0.5, stratify=val_test_labels, random_state=SEED\n", - " )\n", - "\n", - " # Subset dataframe for train, validation and test\n", - " # The isic_id column will be used to fetch the images when dataloading\n", - " # The dataframe index is reset for ease of access at dataloading phase\n", - " train_samples = data_df[data_df[\"isic_id\"].isin(train_ids)].reset_index(drop=True)\n", - " val_samples = data_df[data_df[\"isic_id\"].isin(val_ids)].reset_index(drop=True)\n", - " test_samples = data_df[data_df[\"isic_id\"].isin(test_ids)].reset_index(drop=True)\n", - "\n", - " # Oversample the minority class in the training set\n", - " # There will be an equal amount of rows for each class\n", - " normal_samples_size = train_samples[train_samples[\"target\"]== 0].shape[0]\n", - " melanoma_sample = train_samples[train_samples[\"target\"]== 1]\n", - " oversample_sample = melanoma_sample.sample(n=normal_samples_size - melanoma_sample.shape[0], replace=True, random_state=SEED)\n", - "\n", - " # Concatenate the data and the oversaampled data into one dataframe\n", - " train_samples = pd.concat([train_samples, oversample_sample], ignore_index=True)\n", - " train_samples = train_samples.sample(frac=1).reset_index(drop=True)\n", - " # Logic: We duplicate some of the image references in the training data \n", - " # label dataframe. Since the images will be transformed when loaded, this \n", - " # will augment the melanoma samples. We only add duplicated rows as this \n", - " # array is what gets iterated on by the Dataloader. There is no need to \n", - " # duplicate the image, that is useless use of memory. The augmented array \n", - " # is shuffled so that randomisation is ensured when dataloaders iterate \n", - " # the dataset.\n", - "\n", - " return train_samples, val_samples, test_samples" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "ee90ac6d", - "metadata": {}, - "outputs": [], - "source": [ - "class SkinDataset(Dataset):\n", - " \"\"\"\n", - " Custom Dataset class for ISIC images and labels.\n", - " \"\"\"\n", - " def __init__(self, root_dir, items_df, transform:transforms.Compose=None):\n", - "\n", - " # get the image folder path\n", - " self.image_dir = (Path(root_dir) / 'image')\n", - " # get the labels dataframe\n", - " self.items_df = items_df\n", - " # Label names\n", - " self.classes = ['normal', 'melanoma']\n", - "\n", - " # Standard image transformation to which we add supplied tranformations\n", - " self.transform = transforms.Compose(\n", - " (transform.transforms if transform else [])+\n", - " #[transforms.ToPILImage(),\n", - " [transforms.ToTensor(),\n", - " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]\n", - " )\n", - "\n", - " self.len = self.items_df.shape[0] \n", - "\n", - " def __len__(self):\n", - " return self.len\n", - " \n", - " def __getitem__(self, idx):\n", - "\n", - " # Get image information from the dataframe\n", - " item = self.items_df.iloc[idx]\n", - " # Get image label\n", - " label = item[\"target\"]\n", - " # Get image\n", - " image_name = item[\"isic_id\"]\n", - " image = Image.open(self.image_dir / (image_name + \".jpg\")).convert('RGB')\n", - " # Transform image\n", - " image = self.transform(image)\n", - " \n", - " return image, torch.tensor(label, dtype=torch.long)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "79f2811b", - "metadata": {}, - "outputs": [], - "source": [ - "class TripletDataset(Dataset):\n", - " \"\"\"\n", - " Custom Dataset for generating (Anchor, Positive, Negative) triplets.\n", - " \"\"\"\n", - " def __init__(self, root_dir, items_df, transform=None):\n", - " #self.root_dir = root_dir\n", - " #self.transform = transform\n", - " \n", - " # get the image folder path\n", - " self.image_dir = (Path(root_dir) / 'image')\n", - " # get the labels dataframe\n", - " self.items_df = items_df\n", - " # Label names\n", - " self.classes = ['normal', 'melanoma']\n", - "\n", - " # Standard image transformation to which we add supplied tranformations\n", - " self.transform = transforms.Compose(\n", - " (transform.transforms if transform else [])+\n", - " #[transforms.ToPILImage(),\n", - " [transforms.ToTensor(),\n", - " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]\n", - " )\n", - " \n", - " # Total number of unique images to iterate over\n", - " self.len = self.items_df.shape[0] \n", - "\n", - " def __len__(self):\n", - " return self.len\n", - "\n", - " def __getitem__(self, index):\n", - " # 1. Select Anchor (A)\n", - " #anchor_path, anchor_class = self.all_paths[index]\n", - "\n", - " # Get image information from the dataframe\n", - " anchor = self.items_df.iloc[index]\n", - " # Get image label\n", - " anchor_class = anchor[\"target\"]\n", - " # Get image\n", - " anchor_name = anchor[\"isic_id\"]\n", - " anchor_image = Image.open(self.image_dir / (anchor_name + \".jpg\")).convert('RGB')\n", - " # Transform image\n", - " anchor_image = self.transform(anchor_image)\n", - " \n", - " # 2. Select Positive (P)\n", - " # Select an image from the same class as the anchor, but not the anchor itself\n", - " try:\n", - " positive = self.items_df[(self.items_df[\"isic_id\"]!=anchor_name) & (self.items_df[\"target\"]==anchor_class)].sample()\n", - " except:\n", - " # Handle edge case where only one image exists in the class (should not happen in real ISIC)\n", - " positive = anchor\n", - "\n", - " # Get image\n", - " positive_name = positive[\"isic_id\"].item()\n", - " positive_image = Image.open(self.image_dir / (positive_name + \".jpg\")).convert('RGB')\n", - " # Transform image\n", - " positive_image = self.transform(positive_image)\n", - "\n", - " # 3. Select Negative (N)\n", - " # Select a class different from the anchor class (binary case is simple)\n", - " negative_class = 1 - anchor_class\n", - " # Select a negative sample\n", - " negative = self.items_df[self.items_df[\"target\"]==negative_class].sample()\n", - " # Get image\n", - " negative_name = negative[\"isic_id\"].item()\n", - " negative_image = Image.open(self.image_dir / (negative_name + \".jpg\")).convert('RGB')\n", - " # Transform image\n", - " negative_image = self.transform(negative_image)\n", - "\n", - " # Return triplet and the anchor's original label for verification/testing\n", - " return anchor_image, positive_image, negative_image, anchor_class" - ] - }, - { - "cell_type": "markdown", - "id": "839e4757", - "metadata": {}, - "source": [ - "class ClassificationNet(nn.Module):\n", - " \"\"\"\n", - " A simple linear head trained on top of the fixed embeddings \n", - " for the final binary classification (Melanoma vs. Normal).\n", - " \"\"\"\n", - " def __init__(self, embedding_dim):\n", - " super(ClassificationNet, self).__init__()\n", - " self.classifier = nn.Sequential(\n", - " nn.Linear(embedding_dim, 64),\n", - " nn.ReLU(),\n", - " nn.Dropout(0.3),\n", - " nn.Linear(64, 2) # Two classes: 0 (Normal) and 1 (Melanoma)\n", - " )\n", - "\n", - " def forward(self, x):\n", - " return self.classifier(x)" - ] - }, - { - "cell_type": "markdown", - "id": "80fa4cd7", - "metadata": {}, - "source": [ - "class EmbeddingNet(nn.Module):\n", - " \"\"\"Simple non-pretrained CNN to generate image embeddings.\"\"\"\n", - " def __init__(self, image_size=IMAGE_SIZE, out_dim=EMBEDDING_DIM):\n", - " super(EmbeddingNet, self).__init__()\n", - " \n", - " # Output size after Conv1 (256->128) -> Conv2 (128->64) -> Conv3 (64->32) -> Conv4 (32->16)\n", - " # Layer 1: Conv -> ReLU -> Pool\n", - " self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)\n", - " self.bn1 = nn.BatchNorm2d(32)\n", - " self.pool1 = nn.MaxPool2d(2, 2)\n", - " \n", - " # Layer 2: Conv -> ReLU -> Pool\n", - " self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n", - " self.bn2 = nn.BatchNorm2d(64)\n", - " self.pool2 = nn.MaxPool2d(2, 2)\n", - " \n", - " # Layer 3: Conv -> ReLU -> Pool\n", - " self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n", - " self.bn3 = nn.BatchNorm2d(128)\n", - " self.pool3 = nn.MaxPool2d(2, 2)\n", - "\n", - " # Layer 4: Conv -> ReLU -> Pool\n", - " self.conv4 = nn.Conv2d(128, 256, kernel_size=3, padding=1)\n", - " self.bn4 = nn.BatchNorm2d(256)\n", - " self.pool4 = nn.MaxPool2d(2, 2)\n", - " \n", - " # Calculate the size before the first linear layer\n", - " # 256 -> 128 -> 64 -> 32 -> 16. The output size is 16x16 with 256 channels.\n", - " self.fc_input_size = 256 * (image_size // 16) * (image_size // 16) # 256 * 16 * 16 = 65536\n", - "\n", - " # Fully Connected Layer to produce the embedding\n", - " self.fc1 = nn.Linear(self.fc_input_size, 512)\n", - " self.fc_out = nn.Linear(512, out_dim)\n", - "\n", - " # classification head\n", - " self.classifier = ClassificationNet(out_dim)\n", - "\n", - " def forward(self, x):\n", - " x = self.pool1(nn.functional.relu(self.bn1(self.conv1(x))))\n", - " x = self.pool2(nn.functional.relu(self.bn2(self.conv2(x))))\n", - " x = self.pool3(nn.functional.relu(self.bn3(self.conv3(x))))\n", - " x = self.pool4(nn.functional.relu(self.bn4(self.conv4(x))))\n", - " \n", - " # Flatten the feature map\n", - " x = x.view(x.size(0), -1) \n", - " \n", - " x = nn.functional.relu(self.fc1(x))\n", - " # Final embedding output\n", - " x = self.fc_out(x)\n", - " \n", - " # L2-normalize the embedding vector\n", - " x = nn.functional.normalize(x, p=2, dim=1)\n", - " return x\n", - " \n", - " def classify(self, x):\n", - " return self.classifier(x)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "d324fd98", - "metadata": {}, - "outputs": [], - "source": [ - "class EmbeddingNet(nn.Module):\n", - " \"\"\"Simple non-pretrained CNN to generate image embeddings.\"\"\"\n", - " def __init__(self, image_size=IMAGE_SIZE, out_dim=EMBEDDING_DIM):\n", - " super(EmbeddingNet, self).__init__()\n", - " \n", - " # load a ResNet model\n", - " resnet = models.resnet50()\n", - "\n", - " self.extractor = nn.Sequential(*list(resnet.children())[:-1])\n", - "\n", - " self.fc_out = nn.Sequential(\n", - " nn.Linear(2048, 512),\n", - " nn.ReLU(inplace=True),\n", - " nn.Dropout(0.3), # 0.5\n", - " nn.Linear(512, 256),\n", - " nn.ReLU(inplace=True),\n", - " nn.Dropout(0.3), # 0.5\n", - " nn.Linear(256, out_dim)\n", - " )\n", - " \n", - " # Calculate the size before the first linear layer\n", - " # 256 -> 128 -> 64 -> 32 -> 16. The output size is 16x16 with 256 channels.\n", - " #self.fc_input_size = 256 * (image_size // 16) * (image_size // 16) # 256 * 16 * 16 = 65536\n", - "\n", - " # Fully Connected Layer to produce the embedding\n", - " #self.fc1 = nn.Linear(self.fc_input_size, 512)\n", - " #self.fc_out = nn.Linear(512, out_dim)\n", - "\n", - " # classification head\n", - " self.classifier = nn.Linear(out_dim, 2)\n", - "\n", - " def forward(self, x):\n", - " # extract features\n", - " x = self.extractor(x)\n", - " # Flatten the feature map\n", - " x = x.view(x.size(0), -1) \n", - " # Final embedding output\n", - " x = self.fc_out(x)\n", - " \n", - " # L2-normalize the embedding vector\n", - " #x = nn.functional.normalize(x, p=2, dim=1)\n", - " return x\n", - " \n", - " def classify(self, x):\n", - " return self.classifier(x)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "a5701bdd", - "metadata": {}, - "outputs": [], - "source": [ - "class TripletLoss(nn.Module):\n", - " \"\"\"\n", - " Triplet loss function based on the distance between embeddings.\n", - " L(A, P, N) = max(0, ||f(A) - f(P)||^2 - ||f(A) - f(N)||^2 + margin)\n", - " \"\"\"\n", - " def __init__(self, margin=1.0):\n", - " super(TripletLoss, self).__init__()\n", - " self.margin = margin\n", - " self.p = 2 # L2 distance\n", - "\n", - " def forward(self, anchor, positive, negative):\n", - " # Calculate squared L2 distance\n", - " d_pos = nn.functional.pairwise_distance(anchor, positive, p=self.p)\n", - " d_neg = nn.functional.pairwise_distance(anchor, negative, p=self.p)\n", - " \n", - " # Triplet loss formula\n", - " loss = torch.relu(d_pos - d_neg + self.margin).mean()\n", - " return loss" - ] - }, - { - "cell_type": "markdown", - "id": "5932bab8", - "metadata": {}, - "source": [ - "def get_pairwise_distances(embeddings):\n", - " \"\"\"Computes the squared Euclidean distance matrix.\"\"\"\n", - " dot_product = torch.matmul(embeddings, embeddings.T)\n", - " square_norm = torch.diag(dot_product)\n", - " distances = square_norm.unsqueeze(0) - 2.0 * dot_product + square_norm.unsqueeze(1)\n", - " distances[distances < 0] = 0 # Ensure non-negative distances\n", - " #return torch.sqrt(distances + 1e-8)#distances.sqrt()\n", - " mask = (distances == 0.0).float()\n", - "\n", - " # use this mask to set indices with a value of 0 to eps\n", - " distances += mask * 1e-8\n", - "\n", - " # now it is safe to get the square root\n", - " distances = torch.sqrt(distances)\n", - "\n", - " # undo the trick for numerical stability\n", - " distances *= (1.0 - mask)\n", - "\n", - " return distances\n", - "\n", - "def euclidean_distance_matrix(x):\n", - " \"\"\"Efficient computation of Euclidean distance matrix\n", - " Args:\n", - " x: Input tensor of shape (batch_size, embedding_dim)\n", - " \n", - " Returns:\n", - " Distance matrix of shape (batch_size, batch_size)\n", - " \"\"\"\n", - " # step 1 - compute the dot product\n", - "\n", - " # shape: (batch_size, batch_size)\n", - " dot_product = torch.mm(x, x.t())\n", - "\n", - " # step 2 - extract the squared Euclidean norm from the diagonal\n", - "\n", - " # shape: (batch_size,)\n", - " squared_norm = torch.diag(dot_product)\n", - "\n", - " # step 3 - compute squared Euclidean distances\n", - "\n", - " # shape: (batch_size, batch_size)\n", - " distance_matrix = squared_norm.unsqueeze(0) - 2 * dot_product + squared_norm.unsqueeze(1)\n", - "\n", - " # get rid of negative distances due to numerical instabilities\n", - " distance_matrix = F.relu(distance_matrix)\n", - "\n", - " # step 4 - compute the non-squared distances\n", - " \n", - " # handle numerical stability\n", - " # derivative of the square root operation applied to 0 is infinite\n", - " # we need to handle by setting any 0 to eps\n", - " return torch.sqrt(distance_matrix + 1e-8)\n", - " mask = (distance_matrix == 0.0).float()\n", - "\n", - " # use this mask to set indices with a value of 0 to eps\n", - " distance_matrix += mask * 1e-8\n", - "\n", - " # now it is safe to get the square root\n", - " distance_matrix = torch.sqrt(distance_matrix)\n", - "\n", - " # undo the trick for numerical stability\n", - " distance_matrix *= (1.0 - mask)\n", - "\n", - " return distance_matrix\n", - "\n", - "\n", - "def get_triplets(labels, distances):\n", - " \"\"\"\n", - " Performs Batch-Hard Triplet Mining.\n", - " For each anchor, finds the hardest positive and the hardest negative in the batch.\n", - " \"\"\"\n", - " #batch_size = labels.size(0)\n", - " \n", - " # Create mask for positive and negative pairs\n", - " labels_equal = (labels.unsqueeze(0) == labels.unsqueeze(1))\n", - " \n", - " # 1. Hardest Positive (Anchor-Positive distance should be maximized)\n", - " # Mask to select only positive pairs (i.e., same label, excluding self-distance)\n", - " positive_mask = labels_equal.triu(diagonal=1) | labels_equal.tril(diagonal=-1) \n", - " \n", - " # Set non-positive distances to a very small number for maximization (finding the largest distance)\n", - " anchor_positive_dist = distances * positive_mask.float()\n", - " \n", - " # Max distance per row (Anchor) is the hardest positive\n", - " hardest_positive_dist, _ = anchor_positive_dist.max(dim=1, keepdim=True)\n", - " \n", - " # 2. Hardest Negative (Anchor-Negative distance should be minimized)\n", - " # Mask to select only negative pairs (i.e., different label)\n", - " negative_mask = ~labels_equal\n", - " \n", - " # Set non-negative distances to a very large number for minimization (finding the smallest distance)\n", - " # We use a copy to avoid in-place modification of the original distances tensor\n", - " anchor_negative_dist = distances.clone()\n", - " anchor_negative_dist[~negative_mask] = float('inf')\n", - " \n", - " # Min distance per row (Anchor) is the hardest negative\n", - " hardest_negative_dist, _ = anchor_negative_dist.min(dim=1, keepdim=True)\n", - "\n", - " return hardest_positive_dist, hardest_negative_dist\n", - "\n", - "def get_triplet_mask(labels):\n", - " \"\"\"compute a mask for valid triplets\n", - " Args:\n", - " labels: Batch of integer labels. shape: (batch_size,)\n", - " Returns:\n", - " Mask tensor to indicate which triplets are actually valid. Shape: (batch_size, batch_size, batch_size)\n", - " A triplet is valid if:\n", - " `labels[i] == labels[j] and labels[i] != labels[k]`\n", - " and `i`, `j`, `k` are different.\n", - " \"\"\"\n", - " # step 1 - get a mask for distinct indices\n", - "\n", - " # shape: (batch_size, batch_size)\n", - " indices_equal = torch.eye(labels.size()[0], dtype=torch.bool, device=labels.device)\n", - " indices_not_equal = torch.logical_not(indices_equal)\n", - " # shape: (batch_size, batch_size, 1)\n", - " i_not_equal_j = indices_not_equal.unsqueeze(2)\n", - " # shape: (batch_size, 1, batch_size)\n", - " i_not_equal_k = indices_not_equal.unsqueeze(1)\n", - " # shape: (1, batch_size, batch_size)\n", - " j_not_equal_k = indices_not_equal.unsqueeze(0)\n", - " # Shape: (batch_size, batch_size, batch_size)\n", - " distinct_indices = torch.logical_and(torch.logical_and(i_not_equal_j, i_not_equal_k), j_not_equal_k)\n", - "\n", - " # step 2 - get a mask for valid anchor-positive-negative triplets\n", - "\n", - " # shape: (batch_size, batch_size)\n", - " labels_equal = labels.unsqueeze(0) == labels.unsqueeze(1)\n", - " # shape: (batch_size, batch_size, 1)\n", - " i_equal_j = labels_equal.unsqueeze(2)\n", - " # shape: (batch_size, 1, batch_size)\n", - " i_equal_k = labels_equal.unsqueeze(1)\n", - " # shape: (batch_size, batch_size, batch_size)\n", - " valid_indices = torch.logical_and(i_equal_j, torch.logical_not(i_equal_k))\n", - "\n", - " # step 3 - combine two masks\n", - " mask = torch.logical_and(distinct_indices, valid_indices)\n", - "\n", - " return mask\n", - "\n", - "class BatchAllTtripletLoss(nn.Module):\n", - " \"\"\"Uses all valid triplets to compute Triplet loss\n", - " Args:\n", - " margin: Margin value in the Triplet Loss equation\n", - " \"\"\"\n", - " def __init__(self, margin=1.):\n", - " super().__init__()\n", - " self.margin = margin\n", - " \n", - " def forward(self, embeddings, labels):\n", - " \"\"\"computes loss value.\n", - " Args:\n", - " embeddings: Batch of embeddings, e.g., output of the encoder. shape: (batch_size, embedding_dim)\n", - " labels: Batch of integer labels associated with embeddings. shape: (batch_size,)\n", - " Returns:\n", - " Scalar loss value.\n", - " \"\"\"\n", - " # step 1 - get distance matrix\n", - " # shape: (batch_size, batch_size)\n", - " distance_matrix = euclidean_distance_matrix(embeddings)\n", - "\n", - " # step 2 - compute loss values for all triplets by applying broadcasting to distance matrix\n", - "\n", - " # shape: (batch_size, batch_size, 1)\n", - " anchor_positive_dists = distance_matrix.unsqueeze(2)\n", - " # shape: (batch_size, 1, batch_size)\n", - " anchor_negative_dists = distance_matrix.unsqueeze(1)\n", - " # get loss values for all possible n^3 triplets\n", - " # shape: (batch_size, batch_size, batch_size)\n", - " triplet_loss = anchor_positive_dists - anchor_negative_dists + self.margin\n", - "\n", - " # step 3 - filter out invalid or easy triplets by setting their loss values to 0\n", - "\n", - " # shape: (batch_size, batch_size, batch_size)\n", - " mask = get_triplet_mask(labels)\n", - " triplet_loss *= mask\n", - " # easy triplets have negative loss values\n", - " triplet_loss = F.relu(triplet_loss)\n", - "\n", - " # step 4 - compute scalar loss value by averaging positive losses\n", - " num_positive_losses = (triplet_loss > 1e-8).float().sum()\n", - " triplet_loss = triplet_loss.sum() / (num_positive_losses + 1e-8)\n", - "\n", - " return triplet_loss\n", - " \n", - "\n", - "class TripletMarginLoss(nn.Module):\n", - " \"\"\"\n", - " Combines Triplet Loss with Batch-Hard mining.\n", - " \"\"\"\n", - " def __init__(self, margin):\n", - " super(TripletMarginLoss, self).__init__()\n", - " self.margin = margin\n", - " \n", - " def forward(self, embeddings, labels):\n", - " # Get pairwise distances\n", - " distances = get_pairwise_distances(embeddings)\n", - " \n", - " # Perform Batch-Hard mining to find the hardest (Ap) and (An) for each Anchor\n", - " hardest_positive_dist, hardest_negative_dist = get_triplets(labels, distances)\n", - " \n", - " # Calculate Triplet Loss: max(0, d(a,p) - d(a,n) + margin)\n", - " losses = torch.relu(hardest_positive_dist - hardest_negative_dist + self.margin)\n", - " \n", - " # Only consider anchors that had at least one valid hard positive and hard negative\n", - " # In this Batch-Hard implementation, every anchor should theoretically have a pair \n", - " # as long as the batch is sampled to be balanced (which it is via the DataLoader shuffle).\n", - " \n", - " return losses.mean()" - ] - }, - { - "cell_type": "markdown", - "id": "cffbcedc", - "metadata": {}, - "source": [ - "def train_embedding_net(model, train_loader, criterion, optimizer, epochs, device):\n", - " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", - " model.train()\n", - " print(\"\\n--- Training Embedding Network (Metric Learning) ---\")\n", - " \n", - " for epoch in range(1, epochs + 1):\n", - " running_loss = 0.0\n", - " for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - " \n", - " optimizer.zero_grad()\n", - " \n", - " # Generate embeddings\n", - " embeddings = model(images)\n", - " \n", - " # Calculate Triplet Loss using Batch-Hard mining\n", - " loss = criterion(embeddings, labels)\n", - " \n", - " loss.backward()\n", - " optimizer.step()\n", - " \n", - " running_loss += loss.item() * len(images)\n", - " \n", - " if (i + 1) % 50 == 0:\n", - " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Loss: {loss.item():.4f}')\n", - "\n", - " epoch_loss = running_loss / len(train_loader.dataset)\n", - " print(f\"Epoch {epoch} finished. Average Loss: {epoch_loss:.4f}\")\n", - "\n", - " print(\"Embedding network training complete.\")" - ] - }, - { - "cell_type": "markdown", - "id": "bcb8420a", - "metadata": {}, - "source": [ - "def train_classifier_head(embedding_net, classifier_head, train_loader, criterion, optimizer, epochs, device):\n", - " \"\"\"Trains the Classification Head while freezing the Embedding Net.\"\"\"\n", - " embedding_net.eval()\n", - " classifier_head.train()\n", - " print(\"\\n--- Training Classification Head ---\")\n", - "\n", - " for epoch in range(1, epochs + 1):\n", - " running_loss = 0.0\n", - " correct_predictions = 0\n", - " total_samples = 0\n", - " \n", - " for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - " \n", - " optimizer.zero_grad()\n", - "\n", - " # Generate embeddings (NO GRADIENT)\n", - " with torch.no_grad():\n", - " embeddings = embedding_net(images)\n", - " \n", - " # Classify\n", - " outputs = classifier_head(embeddings)\n", - " loss = criterion(outputs, labels)\n", - " \n", - " loss.backward()\n", - " optimizer.step()\n", - " \n", - " # Statistics\n", - " running_loss += loss.item() * len(images)\n", - " _, preds = torch.max(outputs, 1)\n", - " correct_predictions += torch.sum(preds == labels.data).item()\n", - " total_samples += len(images)\n", - "\n", - " epoch_loss = running_loss / total_samples\n", - " epoch_acc = correct_predictions / total_samples\n", - " print(f\"Epoch {epoch} finished. Avg Loss: {epoch_loss:.4f}, Accuracy: {epoch_acc:.4f}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b8459f00", - "metadata": {}, - "outputs": [], - "source": [ - "def evaluate_model(embedding_net, embedding_crit, classifier_crit, evaluation_loader, device):\n", - " \"\"\"Evaluates the final model on the test set.\"\"\"\n", - " embedding_net.eval()\n", - " \n", - " all_labels = []\n", - " all_predictions = []\n", - " all_probs = []\n", - " emb_running_loss = 0.0\n", - " clas_running_loss = 0.0\n", - " total_samples = 0\n", - " \n", - " with torch.no_grad():\n", - " for images, labels in evaluation_loader:\n", - " images, labels = images.to(device), labels.to(device)\n", - " \n", - " embeddings = embedding_net(images)\n", - " #outputs = embedding_net.classify(embeddings)\n", - "\n", - " emb_loss = embedding_crit(embeddings, labels)\n", - " emb_running_loss += emb_loss.item() * len(images)\n", - "\n", - " #clas_loss = classifier_crit(outputs, labels)\n", - " #clas_running_loss += clas_loss.item() * len(images)\n", - " \n", - " # Predictions and Probabilities\n", - " #_, preds = torch.max(outputs, 1)\n", - " #probs = torch.softmax(outputs, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", - "\n", - " #all_labels.extend(labels.cpu().numpy())\n", - " #all_predictions.extend(preds.cpu().numpy())\n", - " #all_probs.extend(probs.cpu().numpy())\n", - "\n", - " total_samples += len(images)\n", - "\n", - " emb_epoch_loss = emb_running_loss / total_samples\n", - " #clas_epoch_loss = clas_running_loss / total_samples\n", - " #acc = accuracy_score(all_labels, all_predictions)\n", - " #try:\n", - " # AUC is critical for imbalanced data like ISIC\n", - " #auc = roc_auc_score(all_labels, all_probs)\n", - " #except ValueError:\n", - " # Handle cases where only one class is present (unlikely with stratify, but possible with small batches)\n", - " #auc = 0.5 \n", - "\n", - " return emb_epoch_loss#, clas_epoch_loss, acc, auc\n", - " #print(\"\\n--- Final Test Set Results ---\")\n", - " #print(f\"Overall Classification Accuracy: {overall_acc:.4f}\")\n", - " #print(f\"ROC AUC Score (Melanoma): {overall_auc:.4f}\")\n", - "\n", - "\n", - " \n", - " # We target an accuracy of around 0.8\n", - " #if overall_acc >= 0.78:\n", - " # print(\"\\n✅ Target Accuracy Achieved!\")\n", - " #else:\n", - " # print(\"\\n⚠️ Target Accuracy Not Reached in Simulation. Increase epochs or adjust hyperparameters.\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "8d9e9b5c", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_logs(\n", - " emb_train_loss_log, \n", - " clas_train_loss_log,\n", - " train_accuracy_log,\n", - " emb_val_loss_log,\n", - " clas_val_loss_log,\n", - " val_accuracy_log,\n", - " val_ROC_AUC_log,\n", - " epochs):\n", - " \n", - " plt.figure(figsize=(15, 15))\n", - "\n", - " plt.subplot(2, 2, 1)\n", - " plt.plot(range(epochs), emb_train_loss_log, label='Train Loss', color='#F05039')\n", - " plt.plot(range(epochs), emb_val_loss_log, label='Validation Loss', color='#3D65A5')\n", - " plt.title('Embedding Loss over Epochs')\n", - " plt.xlabel('Epochs')\n", - " plt.ylabel('Loss')\n", - " plt.legend()\n", - "\n", - " plt.subplot(2, 2, 2)\n", - " plt.plot(range(epochs), clas_train_loss_log, label='Train Loss', color='#F05039')\n", - " plt.plot(range(epochs), clas_val_loss_log, label='Validation Loss', color='#3D65A5')\n", - " plt.title('Classification Loss over Epochs')\n", - " plt.xlabel('Epochs')\n", - " plt.ylabel('Loss')\n", - " plt.legend()\n", - "\n", - " plt.subplot(2, 2, 3)\n", - " plt.plot(range(epochs), train_accuracy_log, label='Train Accuracy', color='#F05039')\n", - " plt.plot(range(epochs), val_accuracy_log, label='Validation Accuracy', color='#3D65A5')\n", - " plt.title('Accuracy over Epochs')\n", - " plt.xlabel('Epochs')\n", - " plt.ylabel('Accuracy')\n", - " plt.legend()\n", - "\n", - " plt.subplot(2, 2, 4)\n", - " plt.plot(range(epochs), val_ROC_AUC_log, label='ROC AUC', color='#3D65A5')\n", - " plt.title('Validation ROC AUC over Epochs')\n", - " plt.xlabel('Epochs')\n", - " plt.ylabel('ROC AUC')\n", - " plt.legend()\n", - "\n", - " plt.tight_layout()\n", - " plt.savefig('training_logs.png')\n", - " plt.show()\n", - " #plt.close()" - ] - }, - { - "cell_type": "markdown", - "id": "7570a5b9", - "metadata": {}, - "source": [ - "def train_nets(\n", - " embedding_net, classifier_net, \n", - " train_loader, val_loader, \n", - " embedding_crit, classifier_crit, \n", - " embedding_opt, classifier_opt, \n", - " scheduler,\n", - " epochs, \n", - " device):\n", - " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", - " \n", - " print(\"\\n--- Training Networks ---\")\n", - "\n", - " # metric logging intialisation\n", - " best_val_ROC_AUC = -1.0\n", - " emb_train_loss_log = []\n", - " clas_train_loss_log = []\n", - " train_accuracy_log = []\n", - " emb_val_loss_log = []\n", - " clas_val_loss_log = []\n", - " val_accuracy_log = []\n", - " val_ROC_AUC_log = []\n", - " \n", - " for epoch in range(1, epochs + 1):\n", - " embedding_net.train()\n", - " classifier_net.train()\n", - " emb_running_loss = 0.0\n", - " clas_running_loss = 0.0\n", - " correct_predictions = 0\n", - " total_samples = 0\n", - "\n", - " print(f\"\\n==== Training Epoch {epoch} ====\")\n", - "\n", - " # --- Training phase ----\n", - "\n", - " for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - " print(i)\n", - "\n", - " # ---- Embedding model training ----\n", - " embedding_opt.zero_grad()\n", - " \n", - " # Generate embeddings\n", - " embeddings = embedding_net(images)\n", - " \n", - " # Calculate Triplet Loss using Batch-Hard mining\n", - " emb_loss = embedding_crit(embeddings, labels)\n", - " \n", - " emb_loss.backward()\n", - " embedding_opt.step()\n", - " \n", - " emb_running_loss += emb_loss.item() * len(images)\n", - " \n", - " if (i + 1) % 50 == 0:\n", - " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {emb_loss.item():.4f}')\n", - "\n", - " # ---- Classification model training ----\n", - " classifier_opt.zero_grad()\n", - " \n", - " # Classify\n", - " outputs = classifier_net(embeddings)\n", - " clas_loss = classifier_crit(outputs, labels)\n", - " print(clas_loss)\n", - " \n", - " clas_loss.backward()\n", - " classifier_opt.step()\n", - " \n", - " # Statistics\n", - " clas_running_loss += clas_loss.item() * len(images)\n", - " _, preds = torch.max(outputs, 1)\n", - " correct_predictions += torch.sum(preds == labels.data).item()\n", - " total_samples += len(images)\n", - "\n", - " # embedding training epoch loss\n", - " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", - " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", - "\n", - " # classification training epoch loss\n", - " clas_epoch_loss = clas_running_loss / total_samples\n", - " epoch_acc = correct_predictions / total_samples\n", - " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", - " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", - "\n", - " # ---- Evaluation phase ----\n", - "\n", - " print(\"--- Validation phase ---\")\n", - " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", - " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", - " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", - " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", - " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", - "\n", - " # metric logging for plotting\n", - " emb_train_loss_log.append(emb_epoch_loss)\n", - " clas_train_loss_log.append(clas_epoch_loss)\n", - " train_accuracy_log.append(epoch_acc)\n", - " emb_val_loss_log.append(val_emb_loss)\n", - " clas_val_loss_log.append(val_clas_loss)\n", - " val_accuracy_log.append(epoch_val_accuracy)\n", - " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", - "\n", - " scheduler.step(epoch_val_ROC_AUC)\n", - "\n", - " # save best model based on ROC AUC\n", - " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", - " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", - " best_val_ROC_AUC = epoch_val_ROC_AUC\n", - " # Save model checkpoint\n", - " print(\"Saving best model...\")\n", - " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", - " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", - "\n", - "\n", - " print(\"Network training complete.\")\n", - "\n", - " # Graphical display of metric logs\n", - " plot_logs(\n", - " emb_train_loss_log, \n", - " clas_train_loss_log,\n", - " train_accuracy_log,\n", - " emb_val_loss_log,\n", - " clas_val_loss_log,\n", - " val_accuracy_log,\n", - " val_ROC_AUC_log,\n", - " epochs)" - ] - }, - { - "cell_type": "markdown", - "id": "1cdc60c0", - "metadata": {}, - "source": [ - "def train_nets(\n", - " embedding_net, classifier_net, \n", - " train_loader, val_loader, \n", - " embedding_crit, classifier_crit, \n", - " embedding_opt, classifier_opt, \n", - " scheduler,\n", - " epochs, \n", - " device):\n", - " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", - " \n", - " print(\"\\n--- Training Networks ---\")\n", - "\n", - " # metric logging intialisation\n", - " best_val_ROC_AUC = -1.0\n", - " emb_train_loss_log = []\n", - " clas_train_loss_log = []\n", - " train_accuracy_log = []\n", - " emb_val_loss_log = []\n", - " clas_val_loss_log = []\n", - " val_accuracy_log = []\n", - " val_ROC_AUC_log = []\n", - " \n", - " for epoch in range(1, epochs + 1):\n", - " embedding_net.train()\n", - " classifier_net.train()\n", - " emb_running_loss = 0.0\n", - " clas_running_loss = 0.0\n", - " correct_predictions = 0\n", - " total_samples = 0\n", - "\n", - " print(f\"\\n==== Training Epoch {epoch} ====\")\n", - "\n", - " # --- Training phase ----\n", - "\n", - " for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - " #print(i)\n", - "\n", - " # ---- Embedding model training ----\n", - " \n", - " \n", - " # Generate embeddings\n", - " embeddings = embedding_net(images)\n", - " \n", - " # Calculate Triplet Loss using Batch-Hard mining\n", - " emb_loss = embedding_crit(embeddings, labels)\n", - " \n", - " # ---- Classification model training ----\n", - " \n", - " \n", - " # Classify\n", - " outputs = classifier_net(embeddings)\n", - " clas_loss = classifier_crit(outputs, labels)\n", - "\n", - " # Statistics\n", - " emb_running_loss += emb_loss.item() * len(images)\n", - " clas_running_loss += clas_loss.item() * len(images)\n", - " _, preds = torch.max(outputs, 1)\n", - " correct_predictions += torch.sum(preds == labels.data).item()\n", - " total_samples += len(images)\n", - "\n", - " if (i + 1) % 50 == 0:\n", - " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_loss.item()):.4f}, Classification training loss: {(clas_loss.item()):.4f}')\n", - " #print(clas_loss)\n", - "\n", - " total_loss = emb_loss + clas_loss\n", - "\n", - " embedding_opt.zero_grad()\n", - " classifier_opt.zero_grad()\n", - " total_loss.backward()\n", - " embedding_opt.step()\n", - " classifier_opt.step()\n", - "\n", - " # embedding training epoch loss\n", - " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", - " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", - "\n", - " # classification training epoch loss\n", - " clas_epoch_loss = clas_running_loss / total_samples\n", - " epoch_acc = correct_predictions / total_samples\n", - " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", - " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", - "\n", - " # ---- Evaluation phase ----\n", - "\n", - " print(\"--- Validation phase ---\")\n", - " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", - " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", - " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", - " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", - " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", - "\n", - " # metric logging for plotting\n", - " emb_train_loss_log.append(emb_epoch_loss)\n", - " clas_train_loss_log.append(clas_epoch_loss)\n", - " train_accuracy_log.append(epoch_acc)\n", - " emb_val_loss_log.append(val_emb_loss)\n", - " clas_val_loss_log.append(val_clas_loss)\n", - " val_accuracy_log.append(epoch_val_accuracy)\n", - " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", - "\n", - " scheduler.step(epoch_val_ROC_AUC)\n", - "\n", - " # save best model based on ROC AUC\n", - " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", - " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", - " best_val_ROC_AUC = epoch_val_ROC_AUC\n", - " # Save model checkpoint\n", - " print(\"Saving best model...\")\n", - " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", - " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", - "\n", - "\n", - " print(\"Network training complete.\")\n", - "\n", - " # Graphical display of metric logs\n", - " plot_logs(\n", - " emb_train_loss_log, \n", - " clas_train_loss_log,\n", - " train_accuracy_log,\n", - " emb_val_loss_log,\n", - " clas_val_loss_log,\n", - " val_accuracy_log,\n", - " val_ROC_AUC_log,\n", - " epochs)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "e955f931", - "metadata": {}, - "outputs": [], - "source": [ - "def train_nets(\n", - " train_loader, val_loader,\n", - " embedding_net, embedding_opt, \n", - " embedding_crit, classifier_crit,\n", - " scheduler,\n", - " epochs, \n", - " device):\n", - " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", - " \n", - " print(\"\\n--- Training Networks ---\")\n", - "\n", - " # metric logging intialisation\n", - " best_val_ROC_AUC = -1.0\n", - " emb_train_loss_log = []\n", - " clas_train_loss_log = []\n", - " train_accuracy_log = []\n", - " emb_val_loss_log = []\n", - " clas_val_loss_log = []\n", - " val_accuracy_log = []\n", - " val_ROC_AUC_log = []\n", - " \n", - " for epoch in range(1, epochs + 1):\n", - " embedding_net.train()\n", - " #classifier_net.train()\n", - " emb_running_loss = 0.0\n", - " clas_running_loss = 0.0\n", - " correct_predictions = 0\n", - " total_samples = 0\n", - "\n", - " print(f\"\\n==== Training Epoch {epoch} ====\")\n", - " #with torch.autograd.detect_anomaly():\n", - " # --- Training phase ----\n", - "\n", - " for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - "\n", - " # ---- Embedding model training ----\n", - " embedding_opt.zero_grad()\n", - " \n", - " # Generate embeddings\n", - " embeddings = embedding_net(images)\n", - " \n", - " # Calculate Triplet Loss using Batch-Hard mining\n", - " emb_loss = embedding_crit(embeddings, labels)\n", - " \n", - " # ---- Classification model training ----\n", - " \n", - " \n", - " # Classify\n", - " #outputs = embedding_net.classify(embeddings)\n", - " #clas_loss = classifier_crit(outputs, labels)\n", - "\n", - " # Statistics\n", - " emb_running_loss += emb_loss.item() * len(images)\n", - " #clas_running_loss += clas_loss.item() * len(images)\n", - " #_, preds = torch.max(outputs, 1)\n", - " #correct_predictions += torch.sum(preds == labels.data).item()\n", - " total_samples += len(images)\n", - "\n", - " #print(emb_loss.item(), emb_running_loss, clas_loss.item(), clas_running_loss)\n", - " if (i + 1) % 200 == 0:\n", - " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_loss.item()):.4f}')#, Classification training loss: {(clas_loss.item()):.4f}')\n", - " scheduler.step()\n", - " #print(clas_loss)\n", - "\n", - " total_loss = emb_loss #+ clas_loss\n", - " \n", - " total_loss.backward()\n", - " embedding_opt.step()\n", - "\n", - " # embedding training epoch loss\n", - " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", - " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", - "\n", - " # classification training epoch loss\n", - " #clas_epoch_loss = clas_running_loss / total_samples\n", - " #epoch_acc = correct_predictions / total_samples\n", - " #print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", - " #print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", - "\n", - " # ---- Evaluation phase ----\n", - "\n", - " print(\"--- Validation phase ---\")\n", - " val_emb_loss = evaluate_model(embedding_net, embedding_crit, classifier_crit, val_loader, device)\n", - " #val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, embedding_crit, classifier_crit, val_loader, device)\n", - " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", - " #print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", - " #print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", - " #print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", - "\n", - " # metric logging for plotting\n", - " emb_train_loss_log.append(emb_epoch_loss)\n", - " #clas_train_loss_log.append(clas_epoch_loss)\n", - " #train_accuracy_log.append(epoch_acc)\n", - " emb_val_loss_log.append(val_emb_loss)\n", - " #clas_val_loss_log.append(val_clas_loss)\n", - " #val_accuracy_log.append(epoch_val_accuracy)\n", - " #val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", - "\n", - " #scheduler.step(emb_epoch_loss)\n", - "\n", - " # save best model based on ROC AUC\n", - " #if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", - " # print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", - " # best_val_ROC_AUC = epoch_val_ROC_AUC\n", - " # Save model checkpoint\n", - " # print(\"Saving best model...\")\n", - " # torch.save(embedding_net.state_dict(), (Path(DATA_ROOT) / 'best_embedding_model.pth'))\n", - "\n", - "\n", - " print(\"Network training complete.\")\n", - "\n", - " # Graphical display of metric logs\n", - " plot_logs(\n", - " emb_train_loss_log, \n", - " clas_train_loss_log,\n", - " train_accuracy_log,\n", - " emb_val_loss_log,\n", - " clas_val_loss_log,\n", - " val_accuracy_log,\n", - " val_ROC_AUC_log,\n", - " epochs)\n", - " " - ] - }, - { - "cell_type": "markdown", - "id": "03dd5659", - "metadata": {}, - "source": [ - "def train_nets(\n", - " embedding_net, classifier_net, \n", - " train_loader, val_loader, \n", - " embedding_crit, classifier_crit, \n", - " embedding_opt, classifier_opt, \n", - " scheduler,\n", - " epochs, \n", - " device):\n", - " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", - " \n", - " print(\"\\n--- Training Networks ---\")\n", - "\n", - " # metric logging intialisation\n", - " best_val_ROC_AUC = -1.0\n", - " emb_train_loss_log = []\n", - " clas_train_loss_log = []\n", - " train_accuracy_log = []\n", - " emb_val_loss_log = []\n", - " clas_val_loss_log = []\n", - " val_accuracy_log = []\n", - " val_ROC_AUC_log = []\n", - " \n", - " for epoch in range(1, epochs + 1):\n", - " embedding_net.train()\n", - " classifier_net.train()\n", - " emb_running_loss = 0.0\n", - " clas_running_loss = 0.0\n", - " correct_predictions = 0\n", - " total_samples = 0\n", - "\n", - " print(f\"\\n==== Training Epoch {epoch} ====\")\n", - "\n", - " # --- Training phase ----\n", - "\n", - " for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - " print(i)\n", - "\n", - " # ---- Embedding model training ----\n", - " \n", - " embedding_opt.zero_grad()\n", - " classifier_opt.zero_grad()\n", - " \n", - " # Generate embeddings\n", - " embeddings = embedding_net(images)\n", - " \n", - " # Calculate Triplet Loss using Batch-Hard mining\n", - " emb_loss = embedding_crit(embeddings, labels).detach()\n", - " \n", - " \n", - " \n", - " emb_running_loss += emb_loss.item() * len(images)\n", - " \n", - " \n", - "\n", - " # ---- Classification model training ----\n", - "\n", - " \n", - " \n", - " # Classify\n", - " outputs = classifier_net(embeddings)\n", - " clas_loss = classifier_crit(outputs, labels)\n", - "\n", - " if (i + 1) % 50 == 0:\n", - " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {emb_loss.item():.4f}, Classification training loss: {clas_loss.item():.4f}')\n", - " #print(clas_loss)\n", - " \n", - " emb_loss.backward()\n", - " embedding_opt.step()\n", - " embedding_opt.zero_grad()\n", - " clas_loss.backward()\n", - " classifier_opt.step()\n", - " \n", - " # Statistics\n", - " clas_running_loss += clas_loss.item() * len(images)\n", - " _, preds = torch.max(outputs, 1)\n", - " correct_predictions += torch.sum(preds == labels.data).item()\n", - " total_samples += len(images)\n", - "\n", - " # embedding training epoch loss\n", - " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", - " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", - "\n", - " # classification training epoch loss\n", - " clas_epoch_loss = clas_running_loss / total_samples\n", - " epoch_acc = correct_predictions / total_samples\n", - " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", - " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", - "\n", - " # ---- Evaluation phase ----\n", - "\n", - " print(\"--- Validation phase ---\")\n", - " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", - " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", - " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", - " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", - " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", - "\n", - " # metric logging for plotting\n", - " emb_train_loss_log.append(emb_epoch_loss)\n", - " clas_train_loss_log.append(clas_epoch_loss)\n", - " train_accuracy_log.append(epoch_acc)\n", - " emb_val_loss_log.append(val_emb_loss)\n", - " clas_val_loss_log.append(val_clas_loss)\n", - " val_accuracy_log.append(epoch_val_accuracy)\n", - " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", - "\n", - " scheduler.step(epoch_val_ROC_AUC)\n", - "\n", - " # save best model based on ROC AUC\n", - " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", - " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", - " best_val_ROC_AUC = epoch_val_ROC_AUC\n", - " # Save model checkpoint\n", - " print(\"Saving best model...\")\n", - " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", - " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", - "\n", - "\n", - " print(\"Network training complete.\")\n", - "\n", - " # Graphical display of metric logs\n", - " plot_logs(\n", - " emb_train_loss_log, \n", - " clas_train_loss_log,\n", - " train_accuracy_log,\n", - " emb_val_loss_log,\n", - " clas_val_loss_log,\n", - " val_accuracy_log,\n", - " val_ROC_AUC_log,\n", - " epochs)" - ] - }, - { - "cell_type": "markdown", - "id": "407883a9", - "metadata": {}, - "source": [ - "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", - "\n", - "train_dataset = SkinDataset(DATA_ROOT, \n", - " train_samples,\n", - " transform=transforms.Compose([\n", - " transforms.RandomRotation(degrees=10, fill=(255, 255, 255)),\n", - " transforms.RandomHorizontalFlip(p=0.5),\n", - " transforms.RandomVerticalFlip(p=0.5),\n", - " transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.05)\n", - " ]))\n", - "\n", - "val_dataset = SkinDataset(DATA_ROOT, val_samples, transform=None)\n", - "\n", - "# Use standard DataLoader; Triplet mining is handled in the custom loss\n", - "train_loader = DataLoader(train_dataset, batch_size=TRAIN_BATCH_SIZE, shuffle=True, drop_last=True, num_workers=0)\n", - "val_loader = DataLoader(val_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=0)\n", - "\n", - "# Model Setup\n", - "\n", - "# Embedding Net with Triplet Loss\n", - "embedding_net = EmbeddingNet(image_size=IMAGE_SIZE, out_dim=EMBEDDING_DIM).to(device)\n", - "triplet_criterion = BatchAllTtripletLoss(margin=MARGIN)\n", - "embedding_optimizer = optim.Adam(embedding_net.parameters(), lr=1e-5)\n", - "embedding_scheduler = optim.lr_scheduler.OneCycleLR(embedding_optimizer, max_lr=1e-5, steps_per_epoch=8,epochs=7, anneal_strategy=\"cos\")\n", - "#embedding_scheduler = optim.lr_scheduler.CyclicLR(embedding_optimizer, base_lr = 1e-8, max_lr = 1e-5, step_size_up = 4,mode = \"exp_range\")\n", - "#embedding_scheduler = optim.lr_scheduler.ReduceLROnPlateau(embedding_optimizer, mode='min', factor=0.5, patience=5)\n", - "\n", - "# Classification Head with Cross-Entropy Loss\n", - "#classifier_head = ClassificationNet(EMBEDDING_DIM).to(device)\n", - "classification_criterion = nn.CrossEntropyLoss().to(device)\n", - "#classifier_optimizer = optim.Adam(classifier_head.parameters(), lr=LEARNING_RATE)# * 5) # Faster learning rate for small head\n", - "\n", - "train_nets(\n", - " train_loader, val_loader,\n", - " embedding_net, embedding_optimizer, \n", - " triplet_criterion, classification_criterion, \n", - " embedding_scheduler,\n", - " 7, \n", - " device)\n" - ] - }, - { - "cell_type": "markdown", - "id": "efdf32b3", - "metadata": {}, - "source": [ - "def train_epoch(model, dataloader, criterion, optimizer):\n", - " model.train()\n", - " total_loss = 0.0\n", - " for img_a, img_p, img_n, _ in dataloader:\n", - " img_a, img_p, img_n = img_a.to(device), img_p.to(device), img_n.to(device)\n", - "\n", - " optimizer.zero_grad()\n", - " \n", - " # Get embeddings\n", - " emb_a = model(img_a)\n", - " emb_p = model(img_p)\n", - " emb_n = model(img_n)\n", - " \n", - " # Calculate loss\n", - " loss = criterion(emb_a, emb_p, emb_n)\n", - " loss.backward()\n", - " optimizer.step()\n", - " \n", - " total_loss += loss.item() * img_a.size(0)\n", - "\n", - " return total_loss / len(dataloader.dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "81422af3", - "metadata": {}, - "outputs": [], - "source": [ - "def train_epoch(model, dataloader, criterion, classification_crit, optimizer, scheduler, device):\n", - " model.train()\n", - " #total_loss = 0.0\n", - " all_labels = []\n", - " all_predictions = []\n", - " all_probs = []\n", - " emb_running_loss = 0.0\n", - " class_running_loss = 0.0\n", - " total_samples = 0\n", - " #print(\"la\")\n", - " for i, (img_a, img_p, img_n, label_a) in enumerate(dataloader):\n", - "\n", - " #print(\"yo\", i+1)\n", - " img_a, img_p, img_n, label_a = img_a.to(device), img_p.to(device), img_n.to(device), label_a.to(device)\n", - "\n", - " optimizer.zero_grad()\n", - " \n", - " # Get embeddings\n", - " emb_a = model(img_a)\n", - " emb_p = model(img_p)\n", - " emb_n = model(img_n)\n", - " # Calculate loss\n", - " emb_loss = criterion(emb_a, emb_p, emb_n)\n", - "\n", - " # classify anchors\n", - " out_a = model.classify(emb_a)\n", - " # Calculate classification loss\n", - " class_loss = classification_crit(out_a, label_a)\n", - "\n", - " loss = emb_loss + class_loss\n", - "\n", - " #print(\"ya\", loss.item())\n", - " loss.backward()\n", - " optimizer.step()\n", - " \n", - " #total_loss += loss.item() * img_a.size(0)\n", - " total_samples += img_a.size(0)\n", - " emb_running_loss += emb_loss.item() * img_a.size(0)\n", - " class_running_loss += class_loss.item() * img_a.size(0)\n", - "\n", - " # Predictions and Probabilities\n", - " _, preds = torch.max(out_a, 1)\n", - " probs = torch.softmax(out_a, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", - " all_labels.extend(label_a.cpu().numpy())\n", - " all_predictions.extend(preds.cpu().numpy())\n", - " all_probs.extend(probs.cpu().detach().numpy())\n", - "\n", - " #print(\"on est passe\")\n", - "\n", - " if (i + 1) % 50 == 0:\n", - " print(f'Batch {i+1}/{len(dataloader)}, Embedding training loss: {(emb_loss.item()):.4f}, Classification training loss: {(class_loss.item()):.4f}')\n", - " #scheduler.step()\n", - "\n", - " if (i + 1) % 100 == 0:\n", - " scheduler.step()\n", - "\n", - " emb_epoch_loss = emb_running_loss / total_samples\n", - " class_epoch_loss = class_running_loss / total_samples\n", - " acc = accuracy_score(all_labels, all_predictions)\n", - " auc = roc_auc_score(all_labels, all_probs)\n", - " aps = average_precision_score(all_labels, all_probs)\n", - " return emb_epoch_loss, class_epoch_loss, acc, auc, aps" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "0c915db6", - "metadata": {}, - "outputs": [], - "source": [ - "def evaluate(model, dataloader, criterion, classification_crit, device):\n", - " \"\"\"\n", - " Evaluates the model by measuring inter-class distances.\n", - " A simple approach: treat the model as a binary classifier using distance to a fixed 'Normal' centroid.\n", - " NOTE: A more robust Siamese eval would use K-NN or a dedicated classification head.\n", - " \"\"\"\n", - " model.eval()\n", - " #embeddings = []\n", - " #labels = []\n", - " all_labels = []\n", - " all_predictions = []\n", - " all_probs = []\n", - " emb_running_loss = 0.0\n", - " class_running_loss = 0.0\n", - " total_samples = 0\n", - " \n", - " with torch.no_grad():\n", - " for _, (img_a, img_p, img_n, label_a) in enumerate(dataloader):\n", - "\n", - " #print(\"yo\", i+1)\n", - " img_a, img_p, img_n, label_a = img_a.to(device), img_p.to(device), img_n.to(device), label_a.to(device)\n", - " \n", - " # Get embeddings\n", - " emb_a = model(img_a)\n", - " emb_p = model(img_p)\n", - " emb_n = model(img_n)\n", - " # Calculate loss\n", - " emb_loss = criterion(emb_a, emb_p, emb_n)\n", - "\n", - " # classify anchors\n", - " out_a = model.classify(emb_a)\n", - " # Calculate classification loss\n", - " class_loss = classification_crit(out_a, label_a)\n", - " \n", - " #total_loss += loss.item() * img_a.size(0)\n", - " total_samples += img_a.size(0)\n", - " emb_running_loss += emb_loss.item() * img_a.size(0)\n", - " class_running_loss += class_loss.item() * img_a.size(0)\n", - "\n", - " # Predictions and Probabilities\n", - " _, preds = torch.max(out_a, 1)\n", - " probs = torch.softmax(out_a, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", - " all_labels.extend(label_a.cpu().numpy())\n", - " all_predictions.extend(preds.cpu().numpy())\n", - " all_probs.extend(probs.cpu().detach().numpy())\n", - "\n", - " emb_epoch_loss = emb_running_loss / total_samples\n", - " class_epoch_loss = class_running_loss / total_samples\n", - " acc = accuracy_score(all_labels, all_predictions)\n", - " auc = roc_auc_score(all_labels, all_probs)\n", - " aps = average_precision_score(all_labels, all_probs)\n", - " return emb_epoch_loss, class_epoch_loss, acc, auc, aps" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "d6d94681", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "6" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "20000//32//100\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "9ed14bfb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3333.3333333333335" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "20000/6" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "b07fb20d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "20000%6" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "196c123e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using device: cuda\n", - "Number of normal samples in training data subset: 10449\n", - "Number of melanoma samples in training data subset: 10377\n", - "\n", - "--- Starting Training ---\n", - "\n", - "==== Training Epoch 1 ====\n", - "Batch 50/651, Embedding training loss: 0.9814, Classification training loss: 0.6888\n", - "Batch 100/651, Embedding training loss: 1.0644, Classification training loss: 0.6908\n", - "Batch 150/651, Embedding training loss: 1.0644, Classification training loss: 0.6908\n", - "Batch 200/651, Embedding training loss: 1.0753, Classification training loss: 0.6987\n", - "Batch 250/651, Embedding training loss: 0.9547, Classification training loss: 0.7016\n", - "Batch 300/651, Embedding training loss: 0.9953, Classification training loss: 0.6815\n", - "Batch 350/651, Embedding training loss: 0.9992, Classification training loss: 0.6962\n", - "Batch 400/651, Embedding training loss: 0.8949, Classification training loss: 0.7003\n", - "Batch 450/651, Embedding training loss: 0.9874, Classification training loss: 0.6795\n", - "Batch 500/651, Embedding training loss: 1.0594, Classification training loss: 0.6797\n", - "Batch 550/651, Embedding training loss: 1.0385, Classification training loss: 0.6858\n", - "Batch 600/651, Embedding training loss: 0.9611, Classification training loss: 0.6901\n", - "Batch 650/651, Embedding training loss: 0.9665, Classification training loss: 0.6771\n", - "Epoch 1 training finished.\n", - "Average Training Embedding Loss: 1.0055\n", - "Average Training Classification Loss: 0.6911\n", - "Training Classification Accuracy: 0.5297\n", - "Training ROC AUC: 0.5388\n", - "Training Average Precision Score: 0.5309\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9993\n", - "Average Validation Classification Loss: 0.6660\n", - "Validation Classification Accuracy: 0.8814\n", - "Validation ROC AUC: 0.6740\n", - "Validation Average Precision Score: 0.0284\n", - "Previous best average precision score: -1.0000\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 2 ====\n", - "Batch 50/651, Embedding training loss: 1.1315, Classification training loss: 0.6789\n", - "Batch 100/651, Embedding training loss: 0.9980, Classification training loss: 0.6748\n", - "Batch 150/651, Embedding training loss: 1.0653, Classification training loss: 0.6961\n", - "Batch 200/651, Embedding training loss: 0.9769, Classification training loss: 0.6992\n", - "Batch 250/651, Embedding training loss: 0.9894, Classification training loss: 0.6914\n", - "Batch 300/651, Embedding training loss: 0.9823, Classification training loss: 0.6658\n", - "Batch 350/651, Embedding training loss: 0.9492, Classification training loss: 0.6686\n", - "Batch 400/651, Embedding training loss: 1.0491, Classification training loss: 0.6668\n", - "Batch 450/651, Embedding training loss: 1.0348, Classification training loss: 0.6774\n", - "Batch 500/651, Embedding training loss: 0.8528, Classification training loss: 0.6251\n", - "Batch 550/651, Embedding training loss: 0.9261, Classification training loss: 0.5777\n", - "Batch 600/651, Embedding training loss: 1.1215, Classification training loss: 0.5965\n", - "Batch 650/651, Embedding training loss: 0.7349, Classification training loss: 0.5941\n", - "Epoch 2 training finished.\n", - "Average Training Embedding Loss: 0.9783\n", - "Average Training Classification Loss: 0.6629\n", - "Training Classification Accuracy: 0.6066\n", - "Training ROC AUC: 0.6555\n", - "Training Average Precision Score: 0.6138\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.0773\n", - "Average Validation Classification Loss: 0.5449\n", - "Validation Classification Accuracy: 0.7027\n", - "Validation ROC AUC: 0.7736\n", - "Validation Average Precision Score: 0.0677\n", - "Previous best average precision score: 0.0284\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 3 ====\n", - "Batch 50/651, Embedding training loss: 0.9967, Classification training loss: 0.5309\n", - "Batch 100/651, Embedding training loss: 0.8354, Classification training loss: 0.5939\n", - "Batch 150/651, Embedding training loss: 0.8093, Classification training loss: 0.5489\n", - "Batch 200/651, Embedding training loss: 0.8093, Classification training loss: 0.5426\n", - "Batch 250/651, Embedding training loss: 0.8013, Classification training loss: 0.5755\n", - "Batch 300/651, Embedding training loss: 1.0536, Classification training loss: 0.6235\n", - "Batch 350/651, Embedding training loss: 0.8784, Classification training loss: 0.5977\n", - "Batch 400/651, Embedding training loss: 0.8154, Classification training loss: 0.6752\n", - "Batch 450/651, Embedding training loss: 0.9902, Classification training loss: 0.7035\n", - "Batch 500/651, Embedding training loss: 0.7335, Classification training loss: 0.5614\n", - "Batch 550/651, Embedding training loss: 0.8467, Classification training loss: 0.5633\n", - "Batch 600/651, Embedding training loss: 1.1874, Classification training loss: 0.5183\n", - "Batch 650/651, Embedding training loss: 0.7564, Classification training loss: 0.5242\n", - "Epoch 3 training finished.\n", - "Average Training Embedding Loss: 0.9039\n", - "Average Training Classification Loss: 0.5891\n", - "Training Classification Accuracy: 0.6968\n", - "Training ROC AUC: 0.7406\n", - "Training Average Precision Score: 0.6752\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.0705\n", - "Average Validation Classification Loss: 0.5104\n", - "Validation Classification Accuracy: 0.6973\n", - "Validation ROC AUC: 0.7933\n", - "Validation Average Precision Score: 0.0471\n", - "\n", - "==== Training Epoch 4 ====\n", - "Batch 50/651, Embedding training loss: 0.7895, Classification training loss: 0.5246\n", - "Batch 100/651, Embedding training loss: 0.9032, Classification training loss: 0.5530\n", - "Batch 150/651, Embedding training loss: 0.6660, Classification training loss: 0.5359\n", - "Batch 200/651, Embedding training loss: 0.5997, Classification training loss: 0.5260\n", - "Batch 250/651, Embedding training loss: 0.9593, Classification training loss: 0.5289\n", - "Batch 300/651, Embedding training loss: 1.0562, Classification training loss: 0.6078\n", - "Batch 350/651, Embedding training loss: 0.7136, Classification training loss: 0.5684\n", - "Batch 400/651, Embedding training loss: 1.0087, Classification training loss: 0.5611\n", - "Batch 450/651, Embedding training loss: 0.6732, Classification training loss: 0.5002\n", - "Batch 500/651, Embedding training loss: 0.9404, Classification training loss: 0.4909\n", - "Batch 550/651, Embedding training loss: 1.1808, Classification training loss: 0.6539\n", - "Batch 600/651, Embedding training loss: 1.0692, Classification training loss: 0.5513\n", - "Batch 650/651, Embedding training loss: 0.6207, Classification training loss: 0.5648\n", - "Epoch 4 training finished.\n", - "Average Training Embedding Loss: 0.8732\n", - "Average Training Classification Loss: 0.5684\n", - "Training Classification Accuracy: 0.7124\n", - "Training ROC AUC: 0.7586\n", - "Training Average Precision Score: 0.6899\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9885\n", - "Average Validation Classification Loss: 0.4757\n", - "Validation Classification Accuracy: 0.7374\n", - "Validation ROC AUC: 0.8147\n", - "Validation Average Precision Score: 0.0506\n", - "\n", - "==== Training Epoch 5 ====\n", - "Batch 50/651, Embedding training loss: 0.8788, Classification training loss: 0.5046\n", - "Batch 100/651, Embedding training loss: 0.5758, Classification training loss: 0.5636\n", - "Batch 150/651, Embedding training loss: 0.8199, Classification training loss: 0.6014\n", - "Batch 200/651, Embedding training loss: 0.7128, Classification training loss: 0.5589\n", - "Batch 250/651, Embedding training loss: 0.5568, Classification training loss: 0.6317\n", - "Batch 300/651, Embedding training loss: 1.1061, Classification training loss: 0.5681\n", - "Batch 350/651, Embedding training loss: 0.9197, Classification training loss: 0.5215\n", - "Batch 400/651, Embedding training loss: 0.5025, Classification training loss: 0.3584\n", - "Batch 450/651, Embedding training loss: 0.9359, Classification training loss: 0.6003\n", - "Batch 500/651, Embedding training loss: 0.9530, Classification training loss: 0.4965\n", - "Batch 550/651, Embedding training loss: 0.8064, Classification training loss: 0.4985\n", - "Batch 600/651, Embedding training loss: 0.7286, Classification training loss: 0.6053\n", - "Batch 650/651, Embedding training loss: 0.9125, Classification training loss: 0.3933\n", - "Epoch 5 training finished.\n", - "Average Training Embedding Loss: 0.8519\n", - "Average Training Classification Loss: 0.5525\n", - "Training Classification Accuracy: 0.7288\n", - "Training ROC AUC: 0.7781\n", - "Training Average Precision Score: 0.7155\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.0296\n", - "Average Validation Classification Loss: 0.5072\n", - "Validation Classification Accuracy: 0.6942\n", - "Validation ROC AUC: 0.8231\n", - "Validation Average Precision Score: 0.0608\n", - "\n", - "==== Training Epoch 6 ====\n", - "Batch 50/651, Embedding training loss: 0.8554, Classification training loss: 0.5366\n", - "Batch 100/651, Embedding training loss: 0.5760, Classification training loss: 0.4187\n", - "Batch 150/651, Embedding training loss: 0.7630, Classification training loss: 0.4576\n", - "Batch 200/651, Embedding training loss: 0.7559, Classification training loss: 0.6027\n", - "Batch 250/651, Embedding training loss: 0.7760, Classification training loss: 0.4682\n", - "Batch 300/651, Embedding training loss: 1.1682, Classification training loss: 0.7009\n", - "Batch 350/651, Embedding training loss: 0.6723, Classification training loss: 0.4666\n", - "Batch 400/651, Embedding training loss: 0.6785, Classification training loss: 0.5370\n", - "Batch 450/651, Embedding training loss: 0.7802, Classification training loss: 0.4984\n", - "Batch 500/651, Embedding training loss: 0.6565, Classification training loss: 0.4798\n", - "Batch 550/651, Embedding training loss: 1.0335, Classification training loss: 0.7186\n", - "Batch 600/651, Embedding training loss: 0.9819, Classification training loss: 0.5569\n", - "Batch 650/651, Embedding training loss: 0.9631, Classification training loss: 0.5922\n", - "Epoch 6 training finished.\n", - "Average Training Embedding Loss: 0.8311\n", - "Average Training Classification Loss: 0.5390\n", - "Training Classification Accuracy: 0.7383\n", - "Training ROC AUC: 0.7872\n", - "Training Average Precision Score: 0.7226\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9932\n", - "Average Validation Classification Loss: 0.4796\n", - "Validation Classification Accuracy: 0.7003\n", - "Validation ROC AUC: 0.8256\n", - "Validation Average Precision Score: 0.0650\n", - "\n", - "==== Training Epoch 7 ====\n", - "Batch 50/651, Embedding training loss: 0.9541, Classification training loss: 0.5492\n", - "Batch 100/651, Embedding training loss: 0.9200, Classification training loss: 0.4656\n", - "Batch 150/651, Embedding training loss: 0.8133, Classification training loss: 0.4607\n", - "Batch 200/651, Embedding training loss: 0.6303, Classification training loss: 0.4029\n", - "Batch 250/651, Embedding training loss: 0.7636, Classification training loss: 0.5112\n", - "Batch 300/651, Embedding training loss: 0.8579, Classification training loss: 0.4889\n", - "Batch 350/651, Embedding training loss: 0.7224, Classification training loss: 0.5493\n", - "Batch 400/651, Embedding training loss: 0.7694, Classification training loss: 0.5994\n", - "Batch 450/651, Embedding training loss: 0.8307, Classification training loss: 0.4854\n", - "Batch 500/651, Embedding training loss: 0.7928, Classification training loss: 0.5272\n", - "Batch 550/651, Embedding training loss: 0.8093, Classification training loss: 0.4933\n", - "Batch 600/651, Embedding training loss: 0.8663, Classification training loss: 0.4913\n", - "Batch 650/651, Embedding training loss: 0.6242, Classification training loss: 0.6574\n", - "Epoch 7 training finished.\n", - "Average Training Embedding Loss: 0.8100\n", - "Average Training Classification Loss: 0.5295\n", - "Training Classification Accuracy: 0.7459\n", - "Training ROC AUC: 0.7975\n", - "Training Average Precision Score: 0.7371\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.0355\n", - "Average Validation Classification Loss: 0.5955\n", - "Validation Classification Accuracy: 0.6049\n", - "Validation ROC AUC: 0.8286\n", - "Validation Average Precision Score: 0.0742\n", - "Previous best average precision score: 0.0677\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 8 ====\n", - "Batch 50/651, Embedding training loss: 0.8209, Classification training loss: 0.4328\n", - "Batch 100/651, Embedding training loss: 0.9602, Classification training loss: 0.4000\n", - "Batch 150/651, Embedding training loss: 0.8625, Classification training loss: 0.5563\n", - "Batch 200/651, Embedding training loss: 0.6910, Classification training loss: 0.4409\n", - "Batch 250/651, Embedding training loss: 0.6769, Classification training loss: 0.4927\n", - "Batch 300/651, Embedding training loss: 0.5518, Classification training loss: 0.4379\n", - "Batch 350/651, Embedding training loss: 0.6153, Classification training loss: 0.4274\n", - "Batch 400/651, Embedding training loss: 0.7742, Classification training loss: 0.5893\n", - "Batch 450/651, Embedding training loss: 0.6586, Classification training loss: 0.3807\n", - "Batch 500/651, Embedding training loss: 0.7780, Classification training loss: 0.5561\n", - "Batch 550/651, Embedding training loss: 0.7630, Classification training loss: 0.4247\n", - "Batch 600/651, Embedding training loss: 0.7175, Classification training loss: 0.3993\n", - "Batch 650/651, Embedding training loss: 0.9066, Classification training loss: 0.5850\n", - "Epoch 8 training finished.\n", - "Average Training Embedding Loss: 0.8014\n", - "Average Training Classification Loss: 0.5221\n", - "Training Classification Accuracy: 0.7508\n", - "Training ROC AUC: 0.8043\n", - "Training Average Precision Score: 0.7441\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.8372\n", - "Average Validation Classification Loss: 0.3982\n", - "Validation Classification Accuracy: 0.7972\n", - "Validation ROC AUC: 0.8077\n", - "Validation Average Precision Score: 0.0611\n", - "\n", - "==== Training Epoch 9 ====\n", - "Batch 50/651, Embedding training loss: 0.9895, Classification training loss: 0.7234\n", - "Batch 100/651, Embedding training loss: 0.3559, Classification training loss: 0.3481\n", - "Batch 150/651, Embedding training loss: 1.2448, Classification training loss: 0.5577\n", - "Batch 200/651, Embedding training loss: 0.8110, Classification training loss: 0.5135\n", - "Batch 250/651, Embedding training loss: 0.7580, Classification training loss: 0.4050\n", - "Batch 300/651, Embedding training loss: 0.7827, Classification training loss: 0.4640\n", - "Batch 350/651, Embedding training loss: 0.6943, Classification training loss: 0.4753\n", - "Batch 400/651, Embedding training loss: 0.8743, Classification training loss: 0.4532\n", - "Batch 450/651, Embedding training loss: 0.7248, Classification training loss: 0.5431\n", - "Batch 500/651, Embedding training loss: 0.7600, Classification training loss: 0.4946\n", - "Batch 550/651, Embedding training loss: 0.8192, Classification training loss: 0.5486\n", - "Batch 600/651, Embedding training loss: 0.8595, Classification training loss: 0.4499\n", - "Batch 650/651, Embedding training loss: 0.6718, Classification training loss: 0.5051\n", - "Epoch 9 training finished.\n", - "Average Training Embedding Loss: 0.7783\n", - "Average Training Classification Loss: 0.5118\n", - "Training Classification Accuracy: 0.7580\n", - "Training ROC AUC: 0.8105\n", - "Training Average Precision Score: 0.7500\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.8296\n", - "Average Validation Classification Loss: 0.4066\n", - "Validation Classification Accuracy: 0.7416\n", - "Validation ROC AUC: 0.8695\n", - "Validation Average Precision Score: 0.0837\n", - "Previous best average precision score: 0.0742\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 10 ====\n", - "Batch 50/651, Embedding training loss: 0.7851, Classification training loss: 0.5454\n", - "Batch 100/651, Embedding training loss: 0.9918, Classification training loss: 0.6448\n", - "Batch 150/651, Embedding training loss: 0.5441, Classification training loss: 0.4159\n", - "Batch 200/651, Embedding training loss: 0.4936, Classification training loss: 0.3717\n", - "Batch 250/651, Embedding training loss: 0.7519, Classification training loss: 0.4715\n", - "Batch 300/651, Embedding training loss: 0.7512, Classification training loss: 0.5062\n", - "Batch 350/651, Embedding training loss: 0.5844, Classification training loss: 0.3397\n", - "Batch 400/651, Embedding training loss: 0.4680, Classification training loss: 0.3441\n", - "Batch 450/651, Embedding training loss: 0.9670, Classification training loss: 0.5784\n", - "Batch 500/651, Embedding training loss: 0.5391, Classification training loss: 0.3393\n", - "Batch 550/651, Embedding training loss: 0.8944, Classification training loss: 0.5150\n", - "Batch 600/651, Embedding training loss: 0.5685, Classification training loss: 0.4592\n", - "Batch 650/651, Embedding training loss: 0.8363, Classification training loss: 0.4558\n", - "Epoch 10 training finished.\n", - "Average Training Embedding Loss: 0.7546\n", - "Average Training Classification Loss: 0.4953\n", - "Training Classification Accuracy: 0.7678\n", - "Training ROC AUC: 0.8261\n", - "Training Average Precision Score: 0.7702\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.7719\n", - "Average Validation Classification Loss: 0.3991\n", - "Validation Classification Accuracy: 0.7631\n", - "Validation ROC AUC: 0.8551\n", - "Validation Average Precision Score: 0.0973\n", - "Previous best average precision score: 0.0837\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 11 ====\n", - "Batch 50/651, Embedding training loss: 0.5281, Classification training loss: 0.4413\n", - "Batch 100/651, Embedding training loss: 0.8900, Classification training loss: 0.4385\n", - "Batch 150/651, Embedding training loss: 0.7070, Classification training loss: 0.5043\n", - "Batch 200/651, Embedding training loss: 0.4954, Classification training loss: 0.4448\n", - "Batch 250/651, Embedding training loss: 0.5553, Classification training loss: 0.2879\n", - "Batch 300/651, Embedding training loss: 0.6938, Classification training loss: 0.4412\n", - "Batch 350/651, Embedding training loss: 0.8168, Classification training loss: 0.4643\n", - "Batch 400/651, Embedding training loss: 0.7566, Classification training loss: 0.5817\n", - "Batch 450/651, Embedding training loss: 0.8015, Classification training loss: 0.5232\n", - "Batch 500/651, Embedding training loss: 0.6463, Classification training loss: 0.3524\n", - "Batch 550/651, Embedding training loss: 0.8710, Classification training loss: 0.4890\n", - "Batch 600/651, Embedding training loss: 0.7781, Classification training loss: 0.4816\n", - "Batch 650/651, Embedding training loss: 0.5553, Classification training loss: 0.3955\n", - "Epoch 11 training finished.\n", - "Average Training Embedding Loss: 0.7376\n", - "Average Training Classification Loss: 0.4859\n", - "Training Classification Accuracy: 0.7733\n", - "Training ROC AUC: 0.8368\n", - "Training Average Precision Score: 0.7894\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.7819\n", - "Average Validation Classification Loss: 0.4017\n", - "Validation Classification Accuracy: 0.7839\n", - "Validation ROC AUC: 0.8590\n", - "Validation Average Precision Score: 0.0787\n", - "\n", - "==== Training Epoch 12 ====\n", - "Batch 50/651, Embedding training loss: 0.5847, Classification training loss: 0.4041\n", - "Batch 100/651, Embedding training loss: 0.9744, Classification training loss: 0.4036\n", - "Batch 150/651, Embedding training loss: 0.6571, Classification training loss: 0.5972\n", - "Batch 200/651, Embedding training loss: 0.7979, Classification training loss: 0.5364\n", - "Batch 250/651, Embedding training loss: 0.8335, Classification training loss: 0.4855\n", - "Batch 300/651, Embedding training loss: 0.6500, Classification training loss: 0.3375\n", - "Batch 350/651, Embedding training loss: 0.7315, Classification training loss: 0.4496\n", - "Batch 400/651, Embedding training loss: 1.0514, Classification training loss: 0.5969\n", - "Batch 450/651, Embedding training loss: 0.6395, Classification training loss: 0.5005\n", - "Batch 500/651, Embedding training loss: 0.6807, Classification training loss: 0.3561\n", - "Batch 550/651, Embedding training loss: 0.6780, Classification training loss: 0.4558\n", - "Batch 600/651, Embedding training loss: 0.8741, Classification training loss: 0.5701\n", - "Batch 650/651, Embedding training loss: 0.5523, Classification training loss: 0.3818\n", - "Epoch 12 training finished.\n", - "Average Training Embedding Loss: 0.7106\n", - "Average Training Classification Loss: 0.4711\n", - "Training Classification Accuracy: 0.7828\n", - "Training ROC AUC: 0.8462\n", - "Training Average Precision Score: 0.7936\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.7466\n", - "Average Validation Classification Loss: 0.3528\n", - "Validation Classification Accuracy: 0.7842\n", - "Validation ROC AUC: 0.8740\n", - "Validation Average Precision Score: 0.1177\n", - "Previous best average precision score: 0.0973\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 13 ====\n", - "Batch 50/651, Embedding training loss: 0.8383, Classification training loss: 0.5752\n", - "Batch 100/651, Embedding training loss: 0.9829, Classification training loss: 0.7558\n", - "Batch 150/651, Embedding training loss: 0.8435, Classification training loss: 0.4918\n", - "Batch 200/651, Embedding training loss: 0.5702, Classification training loss: 0.3330\n", - "Batch 250/651, Embedding training loss: 0.6973, Classification training loss: 0.4811\n", - "Batch 300/651, Embedding training loss: 0.7610, Classification training loss: 0.3719\n", - "Batch 350/651, Embedding training loss: 0.5912, Classification training loss: 0.4802\n", - "Batch 400/651, Embedding training loss: 0.7882, Classification training loss: 0.5186\n", - "Batch 450/651, Embedding training loss: 0.9239, Classification training loss: 0.5655\n", - "Batch 500/651, Embedding training loss: 0.7098, Classification training loss: 0.4532\n", - "Batch 550/651, Embedding training loss: 0.5725, Classification training loss: 0.5216\n", - "Batch 600/651, Embedding training loss: 0.9100, Classification training loss: 0.5201\n", - "Batch 650/651, Embedding training loss: 0.6551, Classification training loss: 0.3720\n", - "Epoch 13 training finished.\n", - "Average Training Embedding Loss: 0.6991\n", - "Average Training Classification Loss: 0.4619\n", - "Training Classification Accuracy: 0.7872\n", - "Training ROC AUC: 0.8542\n", - "Training Average Precision Score: 0.8098\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.8215\n", - "Average Validation Classification Loss: 0.3910\n", - "Validation Classification Accuracy: 0.7661\n", - "Validation ROC AUC: 0.8556\n", - "Validation Average Precision Score: 0.0963\n", - "\n", - "==== Training Epoch 14 ====\n", - "Batch 50/651, Embedding training loss: 0.8417, Classification training loss: 0.4855\n", - "Batch 100/651, Embedding training loss: 0.8431, Classification training loss: 0.5281\n", - "Batch 150/651, Embedding training loss: 0.3674, Classification training loss: 0.3866\n", - "Batch 200/651, Embedding training loss: 0.6458, Classification training loss: 0.5392\n", - "Batch 250/651, Embedding training loss: 0.6582, Classification training loss: 0.3658\n", - "Batch 300/651, Embedding training loss: 0.5948, Classification training loss: 0.4075\n", - "Batch 350/651, Embedding training loss: 0.9094, Classification training loss: 0.3373\n", - "Batch 400/651, Embedding training loss: 0.6534, Classification training loss: 0.4050\n", - "Batch 450/651, Embedding training loss: 0.6752, Classification training loss: 0.4966\n", - "Batch 500/651, Embedding training loss: 0.7509, Classification training loss: 0.3899\n", - "Batch 550/651, Embedding training loss: 0.5609, Classification training loss: 0.4943\n", - "Batch 600/651, Embedding training loss: 0.7503, Classification training loss: 0.4706\n", - "Batch 650/651, Embedding training loss: 0.5930, Classification training loss: 0.3513\n", - "Epoch 14 training finished.\n", - "Average Training Embedding Loss: 0.6568\n", - "Average Training Classification Loss: 0.4406\n", - "Training Classification Accuracy: 0.8018\n", - "Training ROC AUC: 0.8677\n", - "Training Average Precision Score: 0.8223\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.7852\n", - "Average Validation Classification Loss: 0.3775\n", - "Validation Classification Accuracy: 0.7706\n", - "Validation ROC AUC: 0.8573\n", - "Validation Average Precision Score: 0.1178\n", - "Previous best average precision score: 0.1177\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 15 ====\n", - "Batch 50/651, Embedding training loss: 0.4123, Classification training loss: 0.2139\n", - "Batch 100/651, Embedding training loss: 0.6008, Classification training loss: 0.4607\n", - "Batch 150/651, Embedding training loss: 0.5672, Classification training loss: 0.3313\n", - "Batch 200/651, Embedding training loss: 0.6125, Classification training loss: 0.4773\n", - "Batch 250/651, Embedding training loss: 0.6892, Classification training loss: 0.4569\n", - "Batch 300/651, Embedding training loss: 0.6998, Classification training loss: 0.5064\n", - "Batch 350/651, Embedding training loss: 0.4068, Classification training loss: 0.2714\n", - "Batch 400/651, Embedding training loss: 0.7246, Classification training loss: 0.5506\n", - "Batch 450/651, Embedding training loss: 0.7955, Classification training loss: 0.5008\n", - "Batch 500/651, Embedding training loss: 0.5903, Classification training loss: 0.3808\n", - "Batch 550/651, Embedding training loss: 0.8702, Classification training loss: 0.5594\n", - "Batch 600/651, Embedding training loss: 0.5165, Classification training loss: 0.2941\n", - "Batch 650/651, Embedding training loss: 0.6198, Classification training loss: 0.4907\n", - "Epoch 15 training finished.\n", - "Average Training Embedding Loss: 0.6211\n", - "Average Training Classification Loss: 0.4199\n", - "Training Classification Accuracy: 0.8145\n", - "Training ROC AUC: 0.8800\n", - "Training Average Precision Score: 0.8412\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.7887\n", - "Average Validation Classification Loss: 0.4078\n", - "Validation Classification Accuracy: 0.7540\n", - "Validation ROC AUC: 0.8619\n", - "Validation Average Precision Score: 0.1007\n", - "\n", - "==== Training Epoch 16 ====\n", - "Batch 50/651, Embedding training loss: 0.6946, Classification training loss: 0.5163\n", - "Batch 100/651, Embedding training loss: 0.6499, Classification training loss: 0.4882\n", - "Batch 150/651, Embedding training loss: 0.4395, Classification training loss: 0.3323\n", - "Batch 200/651, Embedding training loss: 0.7744, Classification training loss: 0.4424\n", - "Batch 250/651, Embedding training loss: 0.5025, Classification training loss: 0.3415\n", - "Batch 300/651, Embedding training loss: 0.4859, Classification training loss: 0.3215\n", - "Batch 350/651, Embedding training loss: 0.5262, Classification training loss: 0.3886\n", - "Batch 400/651, Embedding training loss: 0.5853, Classification training loss: 0.3929\n", - "Batch 450/651, Embedding training loss: 0.5043, Classification training loss: 0.3737\n", - "Batch 500/651, Embedding training loss: 0.4552, Classification training loss: 0.2965\n", - "Batch 550/651, Embedding training loss: 0.4494, Classification training loss: 0.2355\n", - "Batch 600/651, Embedding training loss: 0.4867, Classification training loss: 0.4064\n", - "Batch 650/651, Embedding training loss: 0.6376, Classification training loss: 0.4071\n", - "Epoch 16 training finished.\n", - "Average Training Embedding Loss: 0.5953\n", - "Average Training Classification Loss: 0.4062\n", - "Training Classification Accuracy: 0.8227\n", - "Training ROC AUC: 0.8882\n", - "Training Average Precision Score: 0.8514\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.7491\n", - "Average Validation Classification Loss: 0.3371\n", - "Validation Classification Accuracy: 0.8089\n", - "Validation ROC AUC: 0.8599\n", - "Validation Average Precision Score: 0.1181\n", - "Previous best average precision score: 0.1178\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 17 ====\n", - "Batch 50/651, Embedding training loss: 0.5636, Classification training loss: 0.5146\n", - "Batch 100/651, Embedding training loss: 0.5816, Classification training loss: 0.2888\n", - "Batch 150/651, Embedding training loss: 0.6097, Classification training loss: 0.4321\n", - "Batch 200/651, Embedding training loss: 0.5214, Classification training loss: 0.4331\n", - "Batch 250/651, Embedding training loss: 0.7853, Classification training loss: 0.5401\n", - "Batch 300/651, Embedding training loss: 0.5282, Classification training loss: 0.3385\n", - "Batch 350/651, Embedding training loss: 0.4272, Classification training loss: 0.4357\n", - "Batch 400/651, Embedding training loss: 0.5382, Classification training loss: 0.3016\n", - "Batch 450/651, Embedding training loss: 0.5986, Classification training loss: 0.3380\n", - "Batch 500/651, Embedding training loss: 0.4560, Classification training loss: 0.4142\n", - "Batch 550/651, Embedding training loss: 0.6533, Classification training loss: 0.5104\n", - "Batch 600/651, Embedding training loss: 0.4958, Classification training loss: 0.2755\n", - "Batch 650/651, Embedding training loss: 0.5306, Classification training loss: 0.3764\n", - "Epoch 17 training finished.\n", - "Average Training Embedding Loss: 0.5622\n", - "Average Training Classification Loss: 0.3798\n", - "Training Classification Accuracy: 0.8386\n", - "Training ROC AUC: 0.9030\n", - "Training Average Precision Score: 0.8700\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.6363\n", - "Average Validation Classification Loss: 0.2618\n", - "Validation Classification Accuracy: 0.8636\n", - "Validation ROC AUC: 0.8773\n", - "Validation Average Precision Score: 0.1327\n", - "Previous best average precision score: 0.1181\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 18 ====\n", - "Batch 50/651, Embedding training loss: 0.5348, Classification training loss: 0.2967\n", - "Batch 100/651, Embedding training loss: 0.6011, Classification training loss: 0.2544\n", - "Batch 150/651, Embedding training loss: 0.4047, Classification training loss: 0.2752\n", - "Batch 200/651, Embedding training loss: 0.6623, Classification training loss: 0.4536\n", - "Batch 250/651, Embedding training loss: 0.5676, Classification training loss: 0.3588\n", - "Batch 300/651, Embedding training loss: 0.4478, Classification training loss: 0.3908\n", - "Batch 350/651, Embedding training loss: 0.6285, Classification training loss: 0.4450\n", - "Batch 400/651, Embedding training loss: 0.6160, Classification training loss: 0.3219\n", - "Batch 450/651, Embedding training loss: 0.4999, Classification training loss: 0.3413\n", - "Batch 500/651, Embedding training loss: 0.6249, Classification training loss: 0.5592\n", - "Batch 550/651, Embedding training loss: 0.4545, Classification training loss: 0.2910\n", - "Batch 600/651, Embedding training loss: 0.5912, Classification training loss: 0.5282\n", - "Batch 650/651, Embedding training loss: 0.5599, Classification training loss: 0.5734\n", - "Epoch 18 training finished.\n", - "Average Training Embedding Loss: 0.5210\n", - "Average Training Classification Loss: 0.3529\n", - "Training Classification Accuracy: 0.8538\n", - "Training ROC AUC: 0.9164\n", - "Training Average Precision Score: 0.8860\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.7597\n", - "Average Validation Classification Loss: 0.3233\n", - "Validation Classification Accuracy: 0.8177\n", - "Validation ROC AUC: 0.8581\n", - "Validation Average Precision Score: 0.0953\n", - "\n", - "==== Training Epoch 19 ====\n", - "Batch 50/651, Embedding training loss: 0.6091, Classification training loss: 0.4542\n", - "Batch 100/651, Embedding training loss: 0.4317, Classification training loss: 0.2660\n", - "Batch 150/651, Embedding training loss: 0.4339, Classification training loss: 0.3528\n", - "Batch 200/651, Embedding training loss: 0.4592, Classification training loss: 0.3125\n", - "Batch 250/651, Embedding training loss: 0.5677, Classification training loss: 0.3097\n", - "Batch 300/651, Embedding training loss: 0.6285, Classification training loss: 0.3751\n", - "Batch 350/651, Embedding training loss: 0.5192, Classification training loss: 0.2138\n", - "Batch 400/651, Embedding training loss: 0.4922, Classification training loss: 0.3339\n", - "Batch 450/651, Embedding training loss: 0.6566, Classification training loss: 0.3866\n", - "Batch 500/651, Embedding training loss: 0.3242, Classification training loss: 0.2338\n", - "Batch 550/651, Embedding training loss: 0.2664, Classification training loss: 0.2496\n", - "Batch 600/651, Embedding training loss: 0.3139, Classification training loss: 0.2356\n", - "Batch 650/651, Embedding training loss: 0.4131, Classification training loss: 0.4012\n", - "Epoch 19 training finished.\n", - "Average Training Embedding Loss: 0.4637\n", - "Average Training Classification Loss: 0.3220\n", - "Training Classification Accuracy: 0.8694\n", - "Training ROC AUC: 0.9296\n", - "Training Average Precision Score: 0.9037\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.7071\n", - "Average Validation Classification Loss: 0.3050\n", - "Validation Classification Accuracy: 0.8427\n", - "Validation ROC AUC: 0.8561\n", - "Validation Average Precision Score: 0.0844\n", - "\n", - "==== Training Epoch 20 ====\n", - "Batch 50/651, Embedding training loss: 0.2178, Classification training loss: 0.2208\n", - "Batch 100/651, Embedding training loss: 0.4566, Classification training loss: 0.4663\n", - "Batch 150/651, Embedding training loss: 0.7322, Classification training loss: 0.5546\n", - "Batch 200/651, Embedding training loss: 0.5214, Classification training loss: 0.4550\n", - "Batch 250/651, Embedding training loss: 0.5975, Classification training loss: 0.2593\n", - "Batch 300/651, Embedding training loss: 0.3942, Classification training loss: 0.3126\n", - "Batch 350/651, Embedding training loss: 0.3458, Classification training loss: 0.1962\n", - "Batch 400/651, Embedding training loss: 0.5950, Classification training loss: 0.3228\n", - "Batch 450/651, Embedding training loss: 0.3434, Classification training loss: 0.2602\n", - "Batch 500/651, Embedding training loss: 0.2202, Classification training loss: 0.1537\n", - "Batch 550/651, Embedding training loss: 0.2539, Classification training loss: 0.3150\n", - "Batch 600/651, Embedding training loss: 0.2676, Classification training loss: 0.2205\n", - "Batch 650/651, Embedding training loss: 0.3217, Classification training loss: 0.1518\n", - "Epoch 20 training finished.\n", - "Average Training Embedding Loss: 0.4138\n", - "Average Training Classification Loss: 0.2892\n", - "Training Classification Accuracy: 0.8860\n", - "Training ROC AUC: 0.9427\n", - "Training Average Precision Score: 0.9208\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.7208\n", - "Average Validation Classification Loss: 0.3156\n", - "Validation Classification Accuracy: 0.8349\n", - "Validation ROC AUC: 0.8468\n", - "Validation Average Precision Score: 0.0931\n", - "\n", - "==== Training Epoch 21 ====\n", - "Batch 50/651, Embedding training loss: 0.4096, Classification training loss: 0.2443\n", - "Batch 100/651, Embedding training loss: 0.3357, Classification training loss: 0.2401\n", - "Batch 150/651, Embedding training loss: 0.3034, Classification training loss: 0.0925\n", - "Batch 200/651, Embedding training loss: 0.5260, Classification training loss: 0.3276\n", - "Batch 250/651, Embedding training loss: 0.2936, Classification training loss: 0.1821\n", - "Batch 300/651, Embedding training loss: 0.2171, Classification training loss: 0.2260\n", - "Batch 350/651, Embedding training loss: 0.4013, Classification training loss: 0.1335\n", - "Batch 400/651, Embedding training loss: 0.4489, Classification training loss: 0.3482\n", - "Batch 450/651, Embedding training loss: 0.2803, Classification training loss: 0.1886\n", - "Batch 500/651, Embedding training loss: 0.4511, Classification training loss: 0.2686\n", - "Batch 550/651, Embedding training loss: 0.2236, Classification training loss: 0.1576\n", - "Batch 600/651, Embedding training loss: 0.5669, Classification training loss: 0.3578\n", - "Batch 650/651, Embedding training loss: 0.4023, Classification training loss: 0.3199\n", - "Epoch 21 training finished.\n", - "Average Training Embedding Loss: 0.3618\n", - "Average Training Classification Loss: 0.2559\n", - "Training Classification Accuracy: 0.9035\n", - "Training ROC AUC: 0.9543\n", - "Training Average Precision Score: 0.9358\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.6419\n", - "Average Validation Classification Loss: 0.2439\n", - "Validation Classification Accuracy: 0.8811\n", - "Validation ROC AUC: 0.8638\n", - "Validation Average Precision Score: 0.0947\n", - "\n", - "==== Training Epoch 22 ====\n", - "Batch 50/651, Embedding training loss: 0.1171, Classification training loss: 0.0874\n", - "Batch 100/651, Embedding training loss: 0.4400, Classification training loss: 0.3304\n", - "Batch 150/651, Embedding training loss: 0.5680, Classification training loss: 0.3058\n", - "Batch 200/651, Embedding training loss: 0.3315, Classification training loss: 0.2982\n", - "Batch 250/651, Embedding training loss: 0.3307, Classification training loss: 0.1391\n", - "Batch 300/651, Embedding training loss: 0.5008, Classification training loss: 0.3338\n", - "Batch 350/651, Embedding training loss: 0.3620, Classification training loss: 0.2957\n", - "Batch 400/651, Embedding training loss: 0.3638, Classification training loss: 0.1990\n", - "Batch 450/651, Embedding training loss: 0.2253, Classification training loss: 0.1246\n", - "Batch 500/651, Embedding training loss: 0.2272, Classification training loss: 0.2437\n", - "Batch 550/651, Embedding training loss: 0.2098, Classification training loss: 0.2413\n", - "Batch 600/651, Embedding training loss: 0.3363, Classification training loss: 0.2020\n", - "Batch 650/651, Embedding training loss: 0.3626, Classification training loss: 0.2289\n", - "Epoch 22 training finished.\n", - "Average Training Embedding Loss: 0.3151\n", - "Average Training Classification Loss: 0.2253\n", - "Training Classification Accuracy: 0.9166\n", - "Training ROC AUC: 0.9641\n", - "Training Average Precision Score: 0.9501\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.6411\n", - "Average Validation Classification Loss: 0.2238\n", - "Validation Classification Accuracy: 0.8962\n", - "Validation ROC AUC: 0.8461\n", - "Validation Average Precision Score: 0.1079\n", - "\n", - "==== Training Epoch 23 ====\n", - "Batch 50/651, Embedding training loss: 0.2112, Classification training loss: 0.1806\n", - "Batch 100/651, Embedding training loss: 0.4800, Classification training loss: 0.3415\n", - "Batch 150/651, Embedding training loss: 0.3744, Classification training loss: 0.2041\n", - "Batch 200/651, Embedding training loss: 0.1354, Classification training loss: 0.0664\n", - "Batch 250/651, Embedding training loss: 0.3826, Classification training loss: 0.2935\n", - "Batch 300/651, Embedding training loss: 0.1737, Classification training loss: 0.1439\n", - "Batch 350/651, Embedding training loss: 0.3591, Classification training loss: 0.2311\n", - "Batch 400/651, Embedding training loss: 0.0462, Classification training loss: 0.0633\n", - "Batch 450/651, Embedding training loss: 0.2281, Classification training loss: 0.1739\n", - "Batch 500/651, Embedding training loss: 0.1184, Classification training loss: 0.1509\n", - "Batch 550/651, Embedding training loss: 0.1437, Classification training loss: 0.0671\n", - "Batch 600/651, Embedding training loss: 0.2187, Classification training loss: 0.1428\n", - "Batch 650/651, Embedding training loss: 0.1784, Classification training loss: 0.1803\n", - "Epoch 23 training finished.\n", - "Average Training Embedding Loss: 0.2648\n", - "Average Training Classification Loss: 0.1985\n", - "Training Classification Accuracy: 0.9295\n", - "Training ROC AUC: 0.9716\n", - "Training Average Precision Score: 0.9621\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.6134\n", - "Average Validation Classification Loss: 0.1980\n", - "Validation Classification Accuracy: 0.9143\n", - "Validation ROC AUC: 0.8558\n", - "Validation Average Precision Score: 0.1008\n", - "\n", - "==== Training Epoch 24 ====\n", - "Batch 50/651, Embedding training loss: 0.2610, Classification training loss: 0.2025\n", - "Batch 100/651, Embedding training loss: 0.3261, Classification training loss: 0.2088\n", - "Batch 150/651, Embedding training loss: 0.0706, Classification training loss: 0.0412\n", - "Batch 200/651, Embedding training loss: 0.2358, Classification training loss: 0.1709\n", - "Batch 250/651, Embedding training loss: 0.1326, Classification training loss: 0.0834\n", - "Batch 300/651, Embedding training loss: 0.3603, Classification training loss: 0.3066\n", - "Batch 350/651, Embedding training loss: 0.1549, Classification training loss: 0.1202\n", - "Batch 400/651, Embedding training loss: 0.1006, Classification training loss: 0.0458\n", - "Batch 450/651, Embedding training loss: 0.1430, Classification training loss: 0.0989\n", - "Batch 500/651, Embedding training loss: 0.1987, Classification training loss: 0.1229\n", - "Batch 550/651, Embedding training loss: 0.5830, Classification training loss: 0.3807\n", - "Batch 600/651, Embedding training loss: 0.1961, Classification training loss: 0.2087\n", - "Batch 650/651, Embedding training loss: 0.1378, Classification training loss: 0.0542\n", - "Epoch 24 training finished.\n", - "Average Training Embedding Loss: 0.2299\n", - "Average Training Classification Loss: 0.1730\n", - "Training Classification Accuracy: 0.9412\n", - "Training ROC AUC: 0.9771\n", - "Training Average Precision Score: 0.9677\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.6288\n", - "Average Validation Classification Loss: 0.1929\n", - "Validation Classification Accuracy: 0.9167\n", - "Validation ROC AUC: 0.8428\n", - "Validation Average Precision Score: 0.1191\n", - "\n", - "==== Training Epoch 25 ====\n", - "Batch 50/651, Embedding training loss: 0.3012, Classification training loss: 0.1150\n", - "Batch 100/651, Embedding training loss: 0.1802, Classification training loss: 0.1372\n", - "Batch 150/651, Embedding training loss: 0.3079, Classification training loss: 0.3724\n", - "Batch 200/651, Embedding training loss: 0.0992, Classification training loss: 0.1121\n", - "Batch 250/651, Embedding training loss: 0.1025, Classification training loss: 0.0804\n", - "Batch 300/651, Embedding training loss: 0.1760, Classification training loss: 0.1273\n", - "Batch 350/651, Embedding training loss: 0.2501, Classification training loss: 0.3684\n", - "Batch 400/651, Embedding training loss: 0.3965, Classification training loss: 0.5171\n", - "Batch 450/651, Embedding training loss: 0.1551, Classification training loss: 0.1296\n", - "Batch 500/651, Embedding training loss: 0.1297, Classification training loss: 0.1108\n", - "Batch 550/651, Embedding training loss: 0.1015, Classification training loss: 0.0716\n", - "Batch 600/651, Embedding training loss: 0.1683, Classification training loss: 0.1902\n", - "Batch 650/651, Embedding training loss: 0.2008, Classification training loss: 0.1230\n", - "Epoch 25 training finished.\n", - "Average Training Embedding Loss: 0.2003\n", - "Average Training Classification Loss: 0.1527\n", - "Training Classification Accuracy: 0.9479\n", - "Training ROC AUC: 0.9817\n", - "Training Average Precision Score: 0.9738\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.6393\n", - "Average Validation Classification Loss: 0.1784\n", - "Validation Classification Accuracy: 0.9230\n", - "Validation ROC AUC: 0.8410\n", - "Validation Average Precision Score: 0.1329\n", - "Previous best average precision score: 0.1327\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 26 ====\n", - "Batch 50/651, Embedding training loss: 0.1266, Classification training loss: 0.1070\n", - "Batch 100/651, Embedding training loss: 0.1499, Classification training loss: 0.0866\n", - "Batch 150/651, Embedding training loss: 0.1913, Classification training loss: 0.1141\n", - "Batch 200/651, Embedding training loss: 0.0733, Classification training loss: 0.0883\n", - "Batch 250/651, Embedding training loss: 0.0604, Classification training loss: 0.0443\n", - "Batch 300/651, Embedding training loss: 0.1261, Classification training loss: 0.0398\n", - "Batch 350/651, Embedding training loss: 0.1466, Classification training loss: 0.0960\n", - "Batch 400/651, Embedding training loss: 0.1277, Classification training loss: 0.1405\n", - "Batch 450/651, Embedding training loss: 0.1452, Classification training loss: 0.1237\n", - "Batch 500/651, Embedding training loss: 0.1997, Classification training loss: 0.1550\n", - "Batch 550/651, Embedding training loss: 0.0140, Classification training loss: 0.0382\n", - "Batch 600/651, Embedding training loss: 0.3122, Classification training loss: 0.1980\n", - "Batch 650/651, Embedding training loss: 0.1221, Classification training loss: 0.1270\n", - "Epoch 26 training finished.\n", - "Average Training Embedding Loss: 0.1788\n", - "Average Training Classification Loss: 0.1406\n", - "Training Classification Accuracy: 0.9534\n", - "Training ROC AUC: 0.9842\n", - "Training Average Precision Score: 0.9778\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.6121\n", - "Average Validation Classification Loss: 0.1719\n", - "Validation Classification Accuracy: 0.9291\n", - "Validation ROC AUC: 0.8214\n", - "Validation Average Precision Score: 0.1111\n", - "\n", - "==== Training Epoch 27 ====\n", - "Batch 50/651, Embedding training loss: 0.2307, Classification training loss: 0.1413\n", - "Batch 100/651, Embedding training loss: 0.3815, Classification training loss: 0.3441\n", - "Batch 150/651, Embedding training loss: 0.2282, Classification training loss: 0.1582\n", - "Batch 200/651, Embedding training loss: 0.2157, Classification training loss: 0.1167\n", - "Batch 250/651, Embedding training loss: 0.1776, Classification training loss: 0.1278\n", - "Batch 300/651, Embedding training loss: 0.2329, Classification training loss: 0.2580\n", - "Batch 350/651, Embedding training loss: 0.0170, Classification training loss: 0.0661\n", - "Batch 400/651, Embedding training loss: 0.0815, Classification training loss: 0.0961\n", - "Batch 450/651, Embedding training loss: 0.1742, Classification training loss: 0.1731\n", - "Batch 500/651, Embedding training loss: 0.1197, Classification training loss: 0.0578\n", - "Batch 550/651, Embedding training loss: 0.2758, Classification training loss: 0.1767\n", - "Batch 600/651, Embedding training loss: 0.1647, Classification training loss: 0.1229\n", - "Batch 650/651, Embedding training loss: 0.0789, Classification training loss: 0.0524\n", - "Epoch 27 training finished.\n", - "Average Training Embedding Loss: 0.1693\n", - "Average Training Classification Loss: 0.1328\n", - "Training Classification Accuracy: 0.9551\n", - "Training ROC AUC: 0.9859\n", - "Training Average Precision Score: 0.9809\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.5960\n", - "Average Validation Classification Loss: 0.1716\n", - "Validation Classification Accuracy: 0.9288\n", - "Validation ROC AUC: 0.8402\n", - "Validation Average Precision Score: 0.1121\n", - "\n", - "==== Training Epoch 28 ====\n", - "Batch 50/651, Embedding training loss: 0.1732, Classification training loss: 0.0865\n", - "Batch 100/651, Embedding training loss: 0.1346, Classification training loss: 0.1097\n", - "Batch 150/651, Embedding training loss: 0.1316, Classification training loss: 0.0870\n", - "Batch 200/651, Embedding training loss: 0.0202, Classification training loss: 0.0323\n", - "Batch 250/651, Embedding training loss: 0.4201, Classification training loss: 0.3247\n", - "Batch 300/651, Embedding training loss: 0.1319, Classification training loss: 0.0757\n", - "Batch 350/651, Embedding training loss: 0.1695, Classification training loss: 0.1587\n", - "Batch 400/651, Embedding training loss: 0.0858, Classification training loss: 0.0690\n", - "Batch 450/651, Embedding training loss: 0.0341, Classification training loss: 0.0697\n", - "Batch 500/651, Embedding training loss: 0.3799, Classification training loss: 0.1981\n", - "Batch 550/651, Embedding training loss: 0.0697, Classification training loss: 0.0523\n", - "Batch 600/651, Embedding training loss: 0.0300, Classification training loss: 0.0570\n", - "Batch 650/651, Embedding training loss: 0.2278, Classification training loss: 0.2162\n", - "Epoch 28 training finished.\n", - "Average Training Embedding Loss: 0.1531\n", - "Average Training Classification Loss: 0.1198\n", - "Training Classification Accuracy: 0.9595\n", - "Training ROC AUC: 0.9886\n", - "Training Average Precision Score: 0.9842\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.6002\n", - "Average Validation Classification Loss: 0.1589\n", - "Validation Classification Accuracy: 0.9378\n", - "Validation ROC AUC: 0.8205\n", - "Validation Average Precision Score: 0.1279\n", - "\n", - "==== Training Epoch 29 ====\n", - "Batch 50/651, Embedding training loss: 0.0288, Classification training loss: 0.0539\n", - "Batch 100/651, Embedding training loss: 0.5394, Classification training loss: 0.4222\n", - "Batch 150/651, Embedding training loss: 0.1293, Classification training loss: 0.1050\n", - "Batch 200/651, Embedding training loss: 0.1853, Classification training loss: 0.2461\n", - "Batch 250/651, Embedding training loss: 0.2276, Classification training loss: 0.2347\n", - "Batch 300/651, Embedding training loss: 0.0000, Classification training loss: 0.0388\n", - "Batch 350/651, Embedding training loss: 0.1204, Classification training loss: 0.1454\n", - "Batch 400/651, Embedding training loss: 0.0916, Classification training loss: 0.0864\n", - "Batch 450/651, Embedding training loss: 0.2690, Classification training loss: 0.1838\n", - "Batch 500/651, Embedding training loss: 0.2087, Classification training loss: 0.2723\n", - "Batch 550/651, Embedding training loss: 0.0838, Classification training loss: 0.0509\n", - "Batch 600/651, Embedding training loss: 0.1108, Classification training loss: 0.0368\n", - "Batch 650/651, Embedding training loss: 0.0543, Classification training loss: 0.0456\n", - "Epoch 29 training finished.\n", - "Average Training Embedding Loss: 0.1495\n", - "Average Training Classification Loss: 0.1209\n", - "Training Classification Accuracy: 0.9605\n", - "Training ROC AUC: 0.9869\n", - "Training Average Precision Score: 0.9804\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.6043\n", - "Average Validation Classification Loss: 0.1678\n", - "Validation Classification Accuracy: 0.9297\n", - "Validation ROC AUC: 0.8402\n", - "Validation Average Precision Score: 0.1281\n", - "\n", - "==== Training Epoch 30 ====\n", - "Batch 50/651, Embedding training loss: 0.1203, Classification training loss: 0.1789\n", - "Batch 100/651, Embedding training loss: 0.1846, Classification training loss: 0.0909\n", - "Batch 150/651, Embedding training loss: 0.0740, Classification training loss: 0.0842\n", - "Batch 200/651, Embedding training loss: 0.1446, Classification training loss: 0.1186\n", - "Batch 250/651, Embedding training loss: 0.1666, Classification training loss: 0.0678\n", - "Batch 300/651, Embedding training loss: 0.1335, Classification training loss: 0.0762\n", - "Batch 350/651, Embedding training loss: 0.1068, Classification training loss: 0.0894\n", - "Batch 400/651, Embedding training loss: 0.1107, Classification training loss: 0.1239\n", - "Batch 450/651, Embedding training loss: 0.2519, Classification training loss: 0.1892\n", - "Batch 500/651, Embedding training loss: 0.0969, Classification training loss: 0.0693\n", - "Batch 550/651, Embedding training loss: 0.0892, Classification training loss: 0.1084\n", - "Batch 600/651, Embedding training loss: 0.1291, Classification training loss: 0.0649\n", - "Batch 650/651, Embedding training loss: 0.2508, Classification training loss: 0.1715\n", - "Epoch 30 training finished.\n", - "Average Training Embedding Loss: 0.1469\n", - "Average Training Classification Loss: 0.1153\n", - "Training Classification Accuracy: 0.9628\n", - "Training ROC AUC: 0.9891\n", - "Training Average Precision Score: 0.9850\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.5961\n", - "Average Validation Classification Loss: 0.1604\n", - "Validation Classification Accuracy: 0.9342\n", - "Validation ROC AUC: 0.8334\n", - "Validation Average Precision Score: 0.1280\n", - "\n", - "--- Training Finished ---\n", - "Best Validation Average Precision Score: 0.1329%\n" - ] - } - ], - "source": [ - "print(f\"Using device: {device}\")\n", - "\n", - "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", - "train_samples = train_samples.sample(frac=0.4).reset_index(drop=True)#frac=0.4\n", - "print(f\"Number of normal samples in training data subset: {train_samples[train_samples[\"target\"]== 0].shape[0]}\")\n", - "print(f\"Number of melanoma samples in training data subset: {train_samples[train_samples[\"target\"]== 1].shape[0]}\")\n", - "\n", - "# Setup DataLoaders\n", - "train_dataset = TripletDataset(DATA_ROOT, train_samples,\n", - " transform=transforms.Compose([\n", - " transforms.RandomRotation(degrees=15, fill=(255, 255, 255)),\n", - " transforms.RandomHorizontalFlip(p=0.5),\n", - " transforms.RandomVerticalFlip(p=0.5),\n", - " transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.05)\n", - " ]))\n", - "\n", - "val_dataset = TripletDataset(DATA_ROOT, val_samples, transform=None)\n", - "\n", - "\n", - "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=0)\n", - "val_loader = DataLoader(val_dataset, batch_size=256, shuffle=True, num_workers=0)\n", - "\n", - "# Setup Model, Loss, Optimizer\n", - "model = EmbeddingNet(out_dim=EMBEDDING_DIM).to(device)\n", - "#model = SiameseNet(embedding_net).to(device)\n", - "criterion = TripletLoss(margin=MARGIN).to(device)\n", - "classifier_crit = nn.CrossEntropyLoss().to(device)\n", - "optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)\n", - "scheduler = optim.lr_scheduler.OneCycleLR(optimizer, max_lr=LEARNING_RATE, steps_per_epoch=train_samples.shape[0]//32//100,epochs=NUM_EPOCHS, anneal_strategy=\"cos\")\n", - "\n", - "# Training Loop\n", - "best_val_AP_score = -1.0\n", - "# metric logging\n", - "emb_train_loss_log = []\n", - "emb_val_loss_log = []\n", - "clas_train_loss_log = []\n", - "clas_val_loss_log = []\n", - "train_accuracy_log = []\n", - "val_accuracy_log = []\n", - "train_ROC_AUC_log = []\n", - "val_ROC_AUC_log = []\n", - "train_AP_score_log = []\n", - "val_AP_score_log = []\n", - "\n", - "print(\"\\n--- Starting Training ---\")\n", - "for epoch in range(1, NUM_EPOCHS + 1):#NUM_EPOCHS\n", - " # Train\n", - " print(f\"\\n==== Training Epoch {epoch} ====\")\n", - " emb_train_loss, class_train_loss, train_acc, train_auc, train_aps = train_epoch(model, train_loader, criterion, classifier_crit, optimizer, scheduler, device)\n", - "\n", - " print(f\"Epoch {epoch} training finished.\")\n", - " print(f\"Average Training Embedding Loss: {emb_train_loss:.4f}\")\n", - " print(f\"Average Training Classification Loss: {class_train_loss:.4f}\")\n", - " print(f\"Training Classification Accuracy: {train_acc:.4f}\")\n", - " print(f\"Training ROC AUC: {train_auc:.4f}\")\n", - " print(f\"Training Average Precision Score: {train_aps:.4f}\")\n", - "\n", - " emb_train_loss_log.append(emb_train_loss)\n", - " clas_train_loss_log.append(class_train_loss)\n", - " train_accuracy_log.append(train_acc)\n", - " train_ROC_AUC_log.append(train_auc)\n", - " train_AP_score_log.append(train_aps)\n", - " \n", - " # Evaluate\n", - " emb_val_loss, class_val_loss, val_acc, val_auc, val_aps = evaluate(model, val_loader, criterion, classifier_crit, device)\n", - " \n", - " print(\"--- Validation phase ---\")\n", - " print(f\"Average Validation Embedding Loss: {emb_val_loss:.4f}\")\n", - " print(f\"Average Validation Classification Loss: {class_val_loss:.4f}\")\n", - " print(f\"Validation Classification Accuracy: {val_acc:.4f}\")\n", - " print(f\"Validation ROC AUC: {val_auc:.4f}\")\n", - " print(f\"Validation Average Precision Score: {val_aps:.4f}\")\n", - "\n", - " emb_val_loss_log.append(emb_val_loss)\n", - " clas_val_loss_log.append(class_val_loss)\n", - " val_accuracy_log.append(val_acc)\n", - " val_ROC_AUC_log.append(val_auc)\n", - " val_AP_score_log.append(val_aps)\n", - "\n", - " # Save best model\n", - " if val_aps > best_val_AP_score:\n", - " print(f\"Previous best average precision score: {best_val_AP_score:.4f}\")\n", - " best_val_AP_score = val_aps\n", - " print(\"Saving best model...\")\n", - " torch.save(model.state_dict(), (Path(DATA_ROOT) / 'best_siamese_model.pth'))\n", - " \n", - "print(\"\\n--- Training Finished ---\")\n", - "print(f\"Best Validation Average Precision Score: {best_val_AP_score:.4f}%\")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "dd91f004", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "

" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10, 5))\n", - "\n", - "plt.subplot(1, 2, 1)\n", - "plt.plot(range(NUM_EPOCHS), emb_train_loss_log, label='Train Loss', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), emb_val_loss_log, label='Validation Loss', color='#384860')\n", - "plt.title('Embedding Loss over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('Loss')\n", - "plt.legend()\n", - "\n", - "plt.subplot(1, 2, 2)\n", - "plt.plot(range(NUM_EPOCHS), clas_train_loss_log, label='Train Loss', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), clas_val_loss_log, label='Validation Loss', color='#384860')\n", - "plt.title('Classification Loss over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('Loss')\n", - "plt.legend()\n", - "\n", - "plt.tight_layout()\n", - "plt.savefig('loss_logs.png')\n", - "plt.show()\n", - "#plt.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "b517098b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(15, 5))\n", - "\n", - "plt.subplot(1, 3, 1)\n", - "plt.plot(range(NUM_EPOCHS), train_accuracy_log, label='Train Accuracy', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), val_accuracy_log, label='Validation Accuracy', color='#384860')\n", - "plt.title('Classification Accuracy over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('Accuracy')\n", - "plt.legend()\n", - "\n", - "plt.subplot(1, 3, 2)\n", - "plt.plot(range(NUM_EPOCHS), train_ROC_AUC_log, label='Train ROC AUC', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), val_ROC_AUC_log, label='Validation ROC AUC', color='#384860')\n", - "plt.title('ROC AUC over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('ROC AUC')\n", - "plt.legend()\n", - "\n", - "plt.subplot(1, 3, 3)\n", - "plt.plot(range(NUM_EPOCHS), train_AP_score_log, label='Train AP Score', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), val_AP_score_log, label='Validation AP Score', color='#384860')\n", - "plt.title('Average Precision Score over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('AP Score')\n", - "plt.legend()\n", - "\n", - "plt.tight_layout()\n", - "plt.savefig('metrics_logs.png')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "bf6527da", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.load_state_dict(torch.load((Path(DATA_ROOT) / 'best_siamese_model.pth')))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6aa07581", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3255" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#test_samples\n", - "test_samples[test_samples[\"target\"]== 0].shape[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "494ce41a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "58" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_samples[test_samples[\"target\"]== 1].shape[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "3145f029", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
isic_idpatient_idtarget
0ISIC_5925370IP_49963130
1ISIC_7676485IP_95133760
2ISIC_2766061IP_10106430
3ISIC_1298092IP_44797360
4ISIC_2657843IP_06734510
............
111ISIC_9583969IP_42811941
112ISIC_9596721IP_07250271
113ISIC_9821002IP_50637561
114ISIC_9955163IP_75072121
115ISIC_9998682IP_25161681
\n", - "

116 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " isic_id patient_id target\n", - "0 ISIC_5925370 IP_4996313 0\n", - "1 ISIC_7676485 IP_9513376 0\n", - "2 ISIC_2766061 IP_1010643 0\n", - "3 ISIC_1298092 IP_4479736 0\n", - "4 ISIC_2657843 IP_0673451 0\n", - ".. ... ... ...\n", - "111 ISIC_9583969 IP_4281194 1\n", - "112 ISIC_9596721 IP_0725027 1\n", - "113 ISIC_9821002 IP_5063756 1\n", - "114 ISIC_9955163 IP_7507212 1\n", - "115 ISIC_9998682 IP_2516168 1\n", - "\n", - "[116 rows x 3 columns]" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_samples_subset = test_samples[test_samples[\"target\"]== 0].sample(n=58)\n", - "test_samples_subset = pd.concat([test_samples_subset, test_samples[test_samples[\"target\"]== 1]], ignore_index=True)\n", - "test_samples_subset" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "6f1f3fb7", - "metadata": {}, - "outputs": [], - "source": [ - "test_dataset = SkinDataset(DATA_ROOT, test_samples_subset, transform=None)\n", - "test_loader = DataLoader(test_dataset, batch_size=256, shuffle=True, num_workers=0)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "604d937a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Test Classification Accuracy: 0.6552\n", - "Test ROC AUC: 0.8954\n", - "Test Average Precision Score: 0.9038\n", - "Test Sensitivity: 0.3276\n", - "Test Specificity: 0.9828\n" - ] - } - ], - "source": [ - "from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix\n", - "model.eval()\n", - "with torch.no_grad():\n", - " test_all_labels = []\n", - " test_all_embeds = []\n", - " test_all_predictions = []\n", - " test_all_probs = []\n", - " for i, (images, labels) in enumerate(test_loader):\n", - " images = images.to(device)\n", - "\n", - " # Get embeddings\n", - " embeddings = model(images)\n", - "\n", - " # classify embeddings\n", - " output = model.classify(embeddings)\n", - "\n", - " # Predictions and Probabilities\n", - " _, preds = torch.max(output, 1)\n", - " probs = torch.softmax(output, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", - " test_all_labels.extend(labels.cpu().numpy())\n", - " test_all_embeds.extend(embeddings.cpu().numpy())\n", - " test_all_predictions.extend(preds.cpu().numpy())\n", - " test_all_probs.extend(probs.cpu().numpy())\n", - "\n", - " test_acc = accuracy_score(test_all_labels, test_all_predictions)\n", - " test_auc = roc_auc_score(test_all_labels, test_all_probs)\n", - " test_aps = average_precision_score(test_all_labels, test_all_probs)\n", - " conf_matrix = confusion_matrix(test_all_labels, test_all_predictions)\n", - " tn, fp, fn, tp = conf_matrix.ravel()\n", - " sensitivity = tp / (tp + fn)\n", - " specificity = tn / (tn + fp)\n", - "\n", - " print(f\"Test Classification Accuracy: {test_acc:.4f}\")\n", - " print(f\"Test ROC AUC: {test_auc:.4f}\")\n", - " print(f\"Test Average Precision Score: {test_aps:.4f}\")\n", - " print(f\"Test Sensitivity: {sensitivity:.4f}\")\n", - " print(f\"Test Specificity: {specificity:.4f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "5d714b27", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "57 1 39 19\n" - ] - } - ], - "source": [ - "print(tn, fp, fn, tp)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "dec88172", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Device type?\n", - "cuda\n", - "\n", - "\n", - "Using device: cuda\n", - "Number of normal samples in training data subset: 7796\n", - "Number of melanoma samples in training data subset: 7824\n", - "\n", - "--- Starting Training ---\n", - "\n", - "==== Training Epoch 1 ====\n", - "Batch 50/489, Embedding training loss: 1.2291, Classification training loss: 0.6680\n", - "Batch 100/489, Embedding training loss: 1.2194, Classification training loss: 0.6734\n", - "Batch 150/489, Embedding training loss: 1.2103, Classification training loss: 0.6826\n", - "Batch 200/489, Embedding training loss: 1.2024, Classification training loss: 0.6869\n", - "Batch 250/489, Embedding training loss: 1.2750, Classification training loss: 0.6723\n", - "Batch 300/489, Embedding training loss: 1.2290, Classification training loss: 0.6932\n", - "Batch 350/489, Embedding training loss: 1.1804, Classification training loss: 0.6351\n", - "Batch 400/489, Embedding training loss: 1.2546, Classification training loss: 0.6403\n", - "Batch 450/489, Embedding training loss: 1.3030, Classification training loss: 0.6636\n", - "Epoch 1 training finished.\n", - "Average Training Embedding Loss: 1.2261\n", - "Average Training Classification Loss: 0.6647\n", - "Training Classification Accuracy: 0.6008\n", - "Training ROC AUC: 0.6544\n", - "Training Average Precision Score: 0.6131\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.2958\n", - "Average Validation Classification Loss: 0.4825\n", - "Validation Classification Accuracy: 0.7398\n", - "Validation ROC AUC: 0.7505\n", - "Validation Average Precision Score: 0.0379\n", - "Previous best average precision score: -1.0000\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 2 ====\n", - "Batch 50/489, Embedding training loss: 0.8047, Classification training loss: 0.4856\n", - "Batch 100/489, Embedding training loss: 1.2141, Classification training loss: 0.7160\n", - "Batch 150/489, Embedding training loss: 1.4164, Classification training loss: 0.6304\n", - "Batch 200/489, Embedding training loss: 1.0531, Classification training loss: 0.5397\n", - "Batch 250/489, Embedding training loss: 0.9719, Classification training loss: 0.5695\n", - "Batch 300/489, Embedding training loss: 1.1750, Classification training loss: 0.5823\n", - "Batch 350/489, Embedding training loss: 0.9875, Classification training loss: 0.5607\n", - "Batch 400/489, Embedding training loss: 0.9145, Classification training loss: 0.4747\n", - "Batch 450/489, Embedding training loss: 0.8770, Classification training loss: 0.6204\n", - "Epoch 2 training finished.\n", - "Average Training Embedding Loss: 1.0878\n", - "Average Training Classification Loss: 0.5825\n", - "Training Classification Accuracy: 0.6965\n", - "Training ROC AUC: 0.7470\n", - "Training Average Precision Score: 0.6878\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.2340\n", - "Average Validation Classification Loss: 0.4445\n", - "Validation Classification Accuracy: 0.7501\n", - "Validation ROC AUC: 0.7888\n", - "Validation Average Precision Score: 0.0562\n", - "Previous best average precision score: 0.0379\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 3 ====\n", - "Batch 50/489, Embedding training loss: 0.9939, Classification training loss: 0.5366\n", - "Batch 100/489, Embedding training loss: 1.1359, Classification training loss: 0.5288\n", - "Batch 150/489, Embedding training loss: 1.2352, Classification training loss: 0.6753\n", - "Batch 200/489, Embedding training loss: 1.0543, Classification training loss: 0.6233\n", - "Batch 250/489, Embedding training loss: 1.0368, Classification training loss: 0.5085\n", - "Batch 300/489, Embedding training loss: 0.9747, Classification training loss: 0.5564\n", - "Batch 350/489, Embedding training loss: 1.0565, Classification training loss: 0.6209\n", - "Batch 400/489, Embedding training loss: 0.8488, Classification training loss: 0.4494\n", - "Batch 450/489, Embedding training loss: 0.8973, Classification training loss: 0.4081\n", - "Epoch 3 training finished.\n", - "Average Training Embedding Loss: 1.0613\n", - "Average Training Classification Loss: 0.5651\n", - "Training Classification Accuracy: 0.7150\n", - "Training ROC AUC: 0.7621\n", - "Training Average Precision Score: 0.7016\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.0484\n", - "Average Validation Classification Loss: 0.3975\n", - "Validation Classification Accuracy: 0.7990\n", - "Validation ROC AUC: 0.8143\n", - "Validation Average Precision Score: 0.0634\n", - "Previous best average precision score: 0.0562\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 4 ====\n", - "Batch 50/489, Embedding training loss: 0.9976, Classification training loss: 0.5343\n", - "Batch 100/489, Embedding training loss: 0.9600, Classification training loss: 0.5241\n", - "Batch 150/489, Embedding training loss: 1.1538, Classification training loss: 0.6352\n", - "Batch 200/489, Embedding training loss: 1.1102, Classification training loss: 0.6456\n", - "Batch 250/489, Embedding training loss: 1.0006, Classification training loss: 0.3857\n", - "Batch 300/489, Embedding training loss: 0.9522, Classification training loss: 0.4590\n", - "Batch 350/489, Embedding training loss: 1.1186, Classification training loss: 0.5615\n", - "Batch 400/489, Embedding training loss: 0.8234, Classification training loss: 0.5293\n", - "Batch 450/489, Embedding training loss: 0.9531, Classification training loss: 0.5855\n", - "Epoch 4 training finished.\n", - "Average Training Embedding Loss: 1.0322\n", - "Average Training Classification Loss: 0.5532\n", - "Training Classification Accuracy: 0.7248\n", - "Training ROC AUC: 0.7704\n", - "Training Average Precision Score: 0.7096\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.1443\n", - "Average Validation Classification Loss: 0.4685\n", - "Validation Classification Accuracy: 0.7157\n", - "Validation ROC AUC: 0.8391\n", - "Validation Average Precision Score: 0.0978\n", - "Previous best average precision score: 0.0634\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 5 ====\n", - "Batch 50/489, Embedding training loss: 0.7046, Classification training loss: 0.4332\n", - "Batch 100/489, Embedding training loss: 0.9904, Classification training loss: 0.5534\n", - "Batch 150/489, Embedding training loss: 1.2673, Classification training loss: 0.5459\n", - "Batch 200/489, Embedding training loss: 1.0398, Classification training loss: 0.5066\n", - "Batch 250/489, Embedding training loss: 1.2607, Classification training loss: 0.5435\n", - "Batch 300/489, Embedding training loss: 0.8245, Classification training loss: 0.5229\n", - "Batch 350/489, Embedding training loss: 0.8250, Classification training loss: 0.4315\n", - "Batch 400/489, Embedding training loss: 1.2565, Classification training loss: 0.7454\n", - "Batch 450/489, Embedding training loss: 1.1872, Classification training loss: 0.5595\n", - "Epoch 5 training finished.\n", - "Average Training Embedding Loss: 1.0065\n", - "Average Training Classification Loss: 0.5334\n", - "Training Classification Accuracy: 0.7410\n", - "Training ROC AUC: 0.7920\n", - "Training Average Precision Score: 0.7329\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.1150\n", - "Average Validation Classification Loss: 0.4862\n", - "Validation Classification Accuracy: 0.7302\n", - "Validation ROC AUC: 0.8381\n", - "Validation Average Precision Score: 0.0796\n", - "\n", - "==== Training Epoch 6 ====\n", - "Batch 50/489, Embedding training loss: 0.7071, Classification training loss: 0.3715\n", - "Batch 100/489, Embedding training loss: 0.8809, Classification training loss: 0.5348\n", - "Batch 150/489, Embedding training loss: 1.1304, Classification training loss: 0.5191\n", - "Batch 200/489, Embedding training loss: 0.9379, Classification training loss: 0.5583\n", - "Batch 250/489, Embedding training loss: 0.8295, Classification training loss: 0.5083\n", - "Batch 300/489, Embedding training loss: 1.0361, Classification training loss: 0.4711\n", - "Batch 350/489, Embedding training loss: 0.8055, Classification training loss: 0.4332\n", - "Batch 400/489, Embedding training loss: 0.8884, Classification training loss: 0.4814\n", - "Batch 450/489, Embedding training loss: 0.7873, Classification training loss: 0.6087\n", - "Epoch 6 training finished.\n", - "Average Training Embedding Loss: 0.9771\n", - "Average Training Classification Loss: 0.5211\n", - "Training Classification Accuracy: 0.7504\n", - "Training ROC AUC: 0.8060\n", - "Training Average Precision Score: 0.7527\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.2448\n", - "Average Validation Classification Loss: 0.5176\n", - "Validation Classification Accuracy: 0.6526\n", - "Validation ROC AUC: 0.8336\n", - "Validation Average Precision Score: 0.0824\n", - "\n", - "==== Training Epoch 7 ====\n", - "Batch 50/489, Embedding training loss: 0.7515, Classification training loss: 0.6266\n", - "Batch 100/489, Embedding training loss: 0.9081, Classification training loss: 0.4062\n", - "Batch 150/489, Embedding training loss: 0.8902, Classification training loss: 0.4663\n", - "Batch 200/489, Embedding training loss: 0.8343, Classification training loss: 0.3998\n", - "Batch 250/489, Embedding training loss: 0.9761, Classification training loss: 0.4855\n", - "Batch 300/489, Embedding training loss: 0.8061, Classification training loss: 0.3599\n", - "Batch 350/489, Embedding training loss: 0.8639, Classification training loss: 0.3803\n", - "Batch 400/489, Embedding training loss: 0.7286, Classification training loss: 0.4330\n", - "Batch 450/489, Embedding training loss: 0.9876, Classification training loss: 0.6691\n", - "Epoch 7 training finished.\n", - "Average Training Embedding Loss: 0.9593\n", - "Average Training Classification Loss: 0.5091\n", - "Training Classification Accuracy: 0.7542\n", - "Training ROC AUC: 0.8152\n", - "Training Average Precision Score: 0.7604\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9520\n", - "Average Validation Classification Loss: 0.4185\n", - "Validation Classification Accuracy: 0.7860\n", - "Validation ROC AUC: 0.8480\n", - "Validation Average Precision Score: 0.0984\n", - "Previous best average precision score: 0.0978\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 8 ====\n", - "Batch 50/489, Embedding training loss: 1.1922, Classification training loss: 0.6307\n", - "Batch 100/489, Embedding training loss: 0.6090, Classification training loss: 0.4098\n", - "Batch 150/489, Embedding training loss: 1.0738, Classification training loss: 0.5409\n", - "Batch 200/489, Embedding training loss: 0.5387, Classification training loss: 0.3968\n", - "Batch 250/489, Embedding training loss: 0.8203, Classification training loss: 0.5223\n", - "Batch 300/489, Embedding training loss: 0.5687, Classification training loss: 0.3749\n", - "Batch 350/489, Embedding training loss: 1.0524, Classification training loss: 0.5344\n", - "Batch 400/489, Embedding training loss: 1.0448, Classification training loss: 0.5943\n", - "Batch 450/489, Embedding training loss: 0.8032, Classification training loss: 0.4603\n", - "Epoch 8 training finished.\n", - "Average Training Embedding Loss: 0.9326\n", - "Average Training Classification Loss: 0.4873\n", - "Training Classification Accuracy: 0.7691\n", - "Training ROC AUC: 0.8327\n", - "Training Average Precision Score: 0.7865\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.0012\n", - "Average Validation Classification Loss: 0.3784\n", - "Validation Classification Accuracy: 0.7908\n", - "Validation ROC AUC: 0.8465\n", - "Validation Average Precision Score: 0.0687\n", - "\n", - "==== Training Epoch 9 ====\n", - "Batch 50/489, Embedding training loss: 0.9461, Classification training loss: 0.4141\n", - "Batch 100/489, Embedding training loss: 1.0565, Classification training loss: 0.5334\n", - "Batch 150/489, Embedding training loss: 0.6842, Classification training loss: 0.4306\n", - "Batch 200/489, Embedding training loss: 1.0137, Classification training loss: 0.5925\n", - "Batch 250/489, Embedding training loss: 0.8436, Classification training loss: 0.5257\n", - "Batch 300/489, Embedding training loss: 0.7291, Classification training loss: 0.4630\n", - "Batch 350/489, Embedding training loss: 0.6523, Classification training loss: 0.5455\n", - "Batch 400/489, Embedding training loss: 1.0234, Classification training loss: 0.5034\n", - "Batch 450/489, Embedding training loss: 0.9522, Classification training loss: 0.5249\n", - "Epoch 9 training finished.\n", - "Average Training Embedding Loss: 0.9134\n", - "Average Training Classification Loss: 0.4819\n", - "Training Classification Accuracy: 0.7716\n", - "Training ROC AUC: 0.8385\n", - "Training Average Precision Score: 0.7960\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.0863\n", - "Average Validation Classification Loss: 0.5239\n", - "Validation Classification Accuracy: 0.6755\n", - "Validation ROC AUC: 0.8486\n", - "Validation Average Precision Score: 0.0837\n", - "\n", - "==== Training Epoch 10 ====\n", - "Batch 50/489, Embedding training loss: 0.7764, Classification training loss: 0.3838\n", - "Batch 100/489, Embedding training loss: 0.7079, Classification training loss: 0.3477\n", - "Batch 150/489, Embedding training loss: 1.3955, Classification training loss: 0.6052\n", - "Batch 200/489, Embedding training loss: 0.9525, Classification training loss: 0.5056\n", - "Batch 250/489, Embedding training loss: 0.8475, Classification training loss: 0.4863\n", - "Batch 300/489, Embedding training loss: 1.2050, Classification training loss: 0.5832\n", - "Batch 350/489, Embedding training loss: 0.7028, Classification training loss: 0.4814\n", - "Batch 400/489, Embedding training loss: 0.9383, Classification training loss: 0.4145\n", - "Batch 450/489, Embedding training loss: 0.8320, Classification training loss: 0.4840\n", - "Epoch 10 training finished.\n", - "Average Training Embedding Loss: 0.8878\n", - "Average Training Classification Loss: 0.4655\n", - "Training Classification Accuracy: 0.7816\n", - "Training ROC AUC: 0.8486\n", - "Training Average Precision Score: 0.8007\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.8475\n", - "Average Validation Classification Loss: 0.3209\n", - "Validation Classification Accuracy: 0.8500\n", - "Validation ROC AUC: 0.8682\n", - "Validation Average Precision Score: 0.1525\n", - "Previous best average precision score: 0.0984\n", - "Saving best model...\n", - "\n", - "==== Training Epoch 11 ====\n", - "Batch 50/489, Embedding training loss: 0.8370, Classification training loss: 0.4316\n", - "Batch 100/489, Embedding training loss: 0.7519, Classification training loss: 0.5466\n", - "Batch 150/489, Embedding training loss: 0.6813, Classification training loss: 0.3645\n", - "Batch 200/489, Embedding training loss: 0.7656, Classification training loss: 0.4648\n", - "Batch 250/489, Embedding training loss: 0.7759, Classification training loss: 0.4096\n", - "Batch 300/489, Embedding training loss: 0.7819, Classification training loss: 0.3226\n", - "Batch 350/489, Embedding training loss: 0.8087, Classification training loss: 0.3124\n", - "Batch 400/489, Embedding training loss: 0.7234, Classification training loss: 0.3700\n", - "Batch 450/489, Embedding training loss: 0.9664, Classification training loss: 0.5462\n", - "Epoch 11 training finished.\n", - "Average Training Embedding Loss: 0.8482\n", - "Average Training Classification Loss: 0.4560\n", - "Training Classification Accuracy: 0.7901\n", - "Training ROC AUC: 0.8559\n", - "Training Average Precision Score: 0.8123\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.0040\n", - "Average Validation Classification Loss: 0.4409\n", - "Validation Classification Accuracy: 0.7458\n", - "Validation ROC AUC: 0.8552\n", - "Validation Average Precision Score: 0.1177\n", - "\n", - "==== Training Epoch 12 ====\n", - "Batch 50/489, Embedding training loss: 0.9079, Classification training loss: 0.4749\n", - "Batch 100/489, Embedding training loss: 1.0245, Classification training loss: 0.5596\n", - "Batch 150/489, Embedding training loss: 0.7863, Classification training loss: 0.4130\n", - "Batch 200/489, Embedding training loss: 0.5819, Classification training loss: 0.4200\n", - "Batch 250/489, Embedding training loss: 0.6744, Classification training loss: 0.4530\n", - "Batch 300/489, Embedding training loss: 0.7230, Classification training loss: 0.4699\n", - "Batch 350/489, Embedding training loss: 0.8756, Classification training loss: 0.3615\n", - "Batch 400/489, Embedding training loss: 1.0906, Classification training loss: 0.4844\n", - "Batch 450/489, Embedding training loss: 1.0297, Classification training loss: 0.4125\n", - "Epoch 12 training finished.\n", - "Average Training Embedding Loss: 0.8197\n", - "Average Training Classification Loss: 0.4362\n", - "Training Classification Accuracy: 0.8038\n", - "Training ROC AUC: 0.8702\n", - "Training Average Precision Score: 0.8317\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 1.0155\n", - "Average Validation Classification Loss: 0.4283\n", - "Validation Classification Accuracy: 0.7468\n", - "Validation ROC AUC: 0.8480\n", - "Validation Average Precision Score: 0.1488\n", - "\n", - "==== Training Epoch 13 ====\n", - "Batch 50/489, Embedding training loss: 0.9346, Classification training loss: 0.4521\n", - "Batch 100/489, Embedding training loss: 0.9398, Classification training loss: 0.4260\n", - "Batch 150/489, Embedding training loss: 0.8344, Classification training loss: 0.4103\n", - "Batch 200/489, Embedding training loss: 1.0912, Classification training loss: 0.5821\n", - "Batch 250/489, Embedding training loss: 0.8141, Classification training loss: 0.5899\n", - "Batch 300/489, Embedding training loss: 0.6168, Classification training loss: 0.3816\n", - "Batch 350/489, Embedding training loss: 0.9447, Classification training loss: 0.5373\n", - "Batch 400/489, Embedding training loss: 0.7222, Classification training loss: 0.3465\n", - "Batch 450/489, Embedding training loss: 0.7424, Classification training loss: 0.3280\n", - "Epoch 13 training finished.\n", - "Average Training Embedding Loss: 0.7580\n", - "Average Training Classification Loss: 0.4129\n", - "Training Classification Accuracy: 0.8156\n", - "Training ROC AUC: 0.8851\n", - "Training Average Precision Score: 0.8490\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9018\n", - "Average Validation Classification Loss: 0.4177\n", - "Validation Classification Accuracy: 0.8017\n", - "Validation ROC AUC: 0.8432\n", - "Validation Average Precision Score: 0.1247\n", - "\n", - "==== Training Epoch 14 ====\n", - "Batch 50/489, Embedding training loss: 0.7272, Classification training loss: 0.2752\n", - "Batch 100/489, Embedding training loss: 0.6938, Classification training loss: 0.2847\n", - "Batch 150/489, Embedding training loss: 0.8206, Classification training loss: 0.4087\n", - "Batch 200/489, Embedding training loss: 0.6333, Classification training loss: 0.4039\n", - "Batch 250/489, Embedding training loss: 0.6019, Classification training loss: 0.3542\n", - "Batch 300/489, Embedding training loss: 0.7713, Classification training loss: 0.4673\n", - "Batch 350/489, Embedding training loss: 0.9842, Classification training loss: 0.4334\n", - "Batch 400/489, Embedding training loss: 1.1315, Classification training loss: 0.6579\n", - "Batch 450/489, Embedding training loss: 0.5050, Classification training loss: 0.2770\n", - "Epoch 14 training finished.\n", - "Average Training Embedding Loss: 0.7081\n", - "Average Training Classification Loss: 0.3841\n", - "Training Classification Accuracy: 0.8328\n", - "Training ROC AUC: 0.9030\n", - "Training Average Precision Score: 0.8778\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9972\n", - "Average Validation Classification Loss: 0.4291\n", - "Validation Classification Accuracy: 0.7781\n", - "Validation ROC AUC: 0.8494\n", - "Validation Average Precision Score: 0.1103\n", - "\n", - "==== Training Epoch 15 ====\n", - "Batch 50/489, Embedding training loss: 0.6011, Classification training loss: 0.4842\n", - "Batch 100/489, Embedding training loss: 0.6779, Classification training loss: 0.2488\n", - "Batch 150/489, Embedding training loss: 0.8385, Classification training loss: 0.4391\n", - "Batch 200/489, Embedding training loss: 0.5015, Classification training loss: 0.3545\n", - "Batch 250/489, Embedding training loss: 0.6723, Classification training loss: 0.4841\n", - "Batch 300/489, Embedding training loss: 0.7481, Classification training loss: 0.4509\n", - "Batch 350/489, Embedding training loss: 0.7315, Classification training loss: 0.5749\n", - "Batch 400/489, Embedding training loss: 0.6282, Classification training loss: 0.3294\n", - "Batch 450/489, Embedding training loss: 0.6168, Classification training loss: 0.2894\n", - "Epoch 15 training finished.\n", - "Average Training Embedding Loss: 0.6638\n", - "Average Training Classification Loss: 0.3619\n", - "Training Classification Accuracy: 0.8440\n", - "Training ROC AUC: 0.9143\n", - "Training Average Precision Score: 0.8896\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.9055\n", - "Average Validation Classification Loss: 0.3784\n", - "Validation Classification Accuracy: 0.8201\n", - "Validation ROC AUC: 0.8651\n", - "Validation Average Precision Score: 0.1353\n", - "\n", - "==== Training Epoch 16 ====\n", - "Batch 50/489, Embedding training loss: 0.7199, Classification training loss: 0.2905\n", - "Batch 100/489, Embedding training loss: 0.5666, Classification training loss: 0.3682\n", - "Batch 150/489, Embedding training loss: 0.6456, Classification training loss: 0.2678\n", - "Batch 200/489, Embedding training loss: 0.4826, Classification training loss: 0.3925\n", - "Batch 250/489, Embedding training loss: 0.6621, Classification training loss: 0.3852\n", - "Batch 300/489, Embedding training loss: 0.6358, Classification training loss: 0.2368\n", - "Batch 350/489, Embedding training loss: 0.9896, Classification training loss: 0.4358\n", - "Batch 400/489, Embedding training loss: 0.5779, Classification training loss: 0.4536\n", - "Batch 450/489, Embedding training loss: 0.6011, Classification training loss: 0.2955\n", - "Epoch 16 training finished.\n", - "Average Training Embedding Loss: 0.5880\n", - "Average Training Classification Loss: 0.3311\n", - "Training Classification Accuracy: 0.8645\n", - "Training ROC AUC: 0.9286\n", - "Training Average Precision Score: 0.9084\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.8240\n", - "Average Validation Classification Loss: 0.3156\n", - "Validation Classification Accuracy: 0.8605\n", - "Validation ROC AUC: 0.8583\n", - "Validation Average Precision Score: 0.1277\n", - "\n", - "==== Training Epoch 17 ====\n", - "Batch 50/489, Embedding training loss: 0.5832, Classification training loss: 0.3522\n", - "Batch 100/489, Embedding training loss: 0.5511, Classification training loss: 0.2928\n", - "Batch 150/489, Embedding training loss: 0.6798, Classification training loss: 0.3243\n", - "Batch 200/489, Embedding training loss: 0.5882, Classification training loss: 0.3193\n", - "Batch 250/489, Embedding training loss: 0.6279, Classification training loss: 0.3731\n", - "Batch 300/489, Embedding training loss: 0.3162, Classification training loss: 0.2309\n", - "Batch 350/489, Embedding training loss: 0.7458, Classification training loss: 0.5176\n", - "Batch 400/489, Embedding training loss: 0.6052, Classification training loss: 0.3291\n", - "Batch 450/489, Embedding training loss: 0.4317, Classification training loss: 0.3208\n", - "Epoch 17 training finished.\n", - "Average Training Embedding Loss: 0.5311\n", - "Average Training Classification Loss: 0.3051\n", - "Training Classification Accuracy: 0.8770\n", - "Training ROC AUC: 0.9391\n", - "Training Average Precision Score: 0.9227\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.8601\n", - "Average Validation Classification Loss: 0.3138\n", - "Validation Classification Accuracy: 0.8581\n", - "Validation ROC AUC: 0.8470\n", - "Validation Average Precision Score: 0.1418\n", - "\n", - "==== Training Epoch 18 ====\n", - "Batch 50/489, Embedding training loss: 0.3317, Classification training loss: 0.1909\n", - "Batch 100/489, Embedding training loss: 0.7411, Classification training loss: 0.5114\n", - "Batch 150/489, Embedding training loss: 0.4861, Classification training loss: 0.2024\n", - "Batch 200/489, Embedding training loss: 0.3582, Classification training loss: 0.2171\n", - "Batch 250/489, Embedding training loss: 0.1845, Classification training loss: 0.1851\n", - "Batch 300/489, Embedding training loss: 0.5099, Classification training loss: 0.2847\n", - "Batch 350/489, Embedding training loss: 0.5629, Classification training loss: 0.4387\n", - "Batch 400/489, Embedding training loss: 0.7201, Classification training loss: 0.4175\n", - "Batch 450/489, Embedding training loss: 0.3677, Classification training loss: 0.1556\n", - "Epoch 18 training finished.\n", - "Average Training Embedding Loss: 0.5013\n", - "Average Training Classification Loss: 0.2844\n", - "Training Classification Accuracy: 0.8862\n", - "Training ROC AUC: 0.9472\n", - "Training Average Precision Score: 0.9316\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.8068\n", - "Average Validation Classification Loss: 0.2969\n", - "Validation Classification Accuracy: 0.8675\n", - "Validation ROC AUC: 0.8571\n", - "Validation Average Precision Score: 0.1223\n", - "\n", - "==== Training Epoch 19 ====\n", - "Batch 50/489, Embedding training loss: 0.3720, Classification training loss: 0.2351\n", - "Batch 100/489, Embedding training loss: 0.4788, Classification training loss: 0.2993\n", - "Batch 150/489, Embedding training loss: 0.7006, Classification training loss: 0.2711\n", - "Batch 200/489, Embedding training loss: 0.3871, Classification training loss: 0.2756\n", - "Batch 250/489, Embedding training loss: 0.4363, Classification training loss: 0.3009\n", - "Batch 300/489, Embedding training loss: 0.2995, Classification training loss: 0.2389\n", - "Batch 350/489, Embedding training loss: 0.7177, Classification training loss: 0.3023\n", - "Batch 400/489, Embedding training loss: 0.6801, Classification training loss: 0.2852\n", - "Batch 450/489, Embedding training loss: 0.6890, Classification training loss: 0.4224\n", - "Epoch 19 training finished.\n", - "Average Training Embedding Loss: 0.4810\n", - "Average Training Classification Loss: 0.2712\n", - "Training Classification Accuracy: 0.8942\n", - "Training ROC AUC: 0.9513\n", - "Training Average Precision Score: 0.9356\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.8278\n", - "Average Validation Classification Loss: 0.2908\n", - "Validation Classification Accuracy: 0.8708\n", - "Validation ROC AUC: 0.8513\n", - "Validation Average Precision Score: 0.1382\n", - "\n", - "==== Training Epoch 20 ====\n", - "Batch 50/489, Embedding training loss: 0.5060, Classification training loss: 0.2847\n", - "Batch 100/489, Embedding training loss: 0.8125, Classification training loss: 0.4230\n", - "Batch 150/489, Embedding training loss: 0.4068, Classification training loss: 0.2326\n", - "Batch 200/489, Embedding training loss: 0.1864, Classification training loss: 0.1215\n", - "Batch 250/489, Embedding training loss: 0.5415, Classification training loss: 0.2060\n", - "Batch 300/489, Embedding training loss: 0.4179, Classification training loss: 0.2265\n", - "Batch 350/489, Embedding training loss: 0.1340, Classification training loss: 0.1215\n", - "Batch 400/489, Embedding training loss: 0.2643, Classification training loss: 0.1865\n", - "Batch 450/489, Embedding training loss: 0.4048, Classification training loss: 0.2571\n", - "Epoch 20 training finished.\n", - "Average Training Embedding Loss: 0.4688\n", - "Average Training Classification Loss: 0.2690\n", - "Training Classification Accuracy: 0.8953\n", - "Training ROC AUC: 0.9519\n", - "Training Average Precision Score: 0.9344\n", - "--- Validation phase ---\n", - "Average Validation Embedding Loss: 0.8669\n", - "Average Validation Classification Loss: 0.3342\n", - "Validation Classification Accuracy: 0.8467\n", - "Validation ROC AUC: 0.8533\n", - "Validation Average Precision Score: 0.1161\n", - "\n", - "--- Training Finished ---\n", - "Best Validation Average Precision Score: 0.1525%\n" - ] - } - ], - "source": [ - "# --- Configuration ---\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "print(\"Device type?\")\n", - "print(device)\n", - "print(\"\\n\")\n", - "\n", - "# Define the paths and parameters prompt 2\n", - "DATA_ROOT = './data' # IMPORTANT: structure of the data root should be data-root> train-metadata.csv\n", - "IMAGE_SIZE = 256 #128\n", - "EMBEDDING_DIM = 128\n", - "MARGIN = 1.25\n", - "#BATCH_SIZE = 16\n", - "NUM_EPOCHS = 20\n", - "LEARNING_RATE = 1e-4\n", - "\n", - "# Hyperparameters prompt 1\n", - "#NUM_SAMPLES = 1500 # Simulate a subset of the dataset\n", - "#VALIDATION_SIZE = 0.1\n", - "#TEST_SIZE = 0.1 #0.2\n", - "TRAIN_BATCH_SIZE = 32 #64\n", - "VAL_TEST_BATCH_SIZE = 512\n", - "#EMBEDDING_DIM = 128\n", - "#MARGIN = 1.0 # Triplet Loss margin\n", - "#LEARNING_RATE = 1e-4\n", - "#NUM_EPOCHS = 20 # Training epochs for the Siamese Network\n", - "#NUM_EPOCHS_CLASSIFIER = 10 # Training epochs for the final classifier\n", - "\n", - "\n", - "print(f\"Using device: {device}\")\n", - "\n", - "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", - "train_samples = train_samples.sample(frac=0.3).reset_index(drop=True)#frac=0.4\n", - "print(f\"Number of normal samples in training data subset: {train_samples[train_samples[\"target\"]== 0].shape[0]}\")\n", - "print(f\"Number of melanoma samples in training data subset: {train_samples[train_samples[\"target\"]== 1].shape[0]}\")\n", - "\n", - "# Setup DataLoaders\n", - "train_dataset = TripletDataset(DATA_ROOT, train_samples,\n", - " transform=transforms.Compose([\n", - " transforms.RandomRotation(degrees=10, fill=(255, 255, 255)),\n", - " transforms.RandomHorizontalFlip(p=0.5),\n", - " transforms.RandomVerticalFlip(p=0.5),\n", - " transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.05)\n", - " ]))\n", - "\n", - "val_dataset = TripletDataset(DATA_ROOT, val_samples, transform=None)\n", - "\n", - "\n", - "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=0)\n", - "val_loader = DataLoader(val_dataset, batch_size=256, shuffle=True, num_workers=0)\n", - "\n", - "# Setup Model, Loss, Optimizer\n", - "model = EmbeddingNet(out_dim=EMBEDDING_DIM).to(device)\n", - "#model = SiameseNet(embedding_net).to(device)\n", - "criterion = TripletLoss(margin=MARGIN).to(device)\n", - "classifier_crit = nn.CrossEntropyLoss().to(device)\n", - "optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)\n", - "scheduler = optim.lr_scheduler.OneCycleLR(optimizer, max_lr=LEARNING_RATE, steps_per_epoch=train_samples.shape[0]//32//100,epochs=NUM_EPOCHS, anneal_strategy=\"cos\")\n", - "\n", - "# Training Loop\n", - "best_val_AP_score = -1.0\n", - "# metric logging\n", - "emb_train_loss_log = []\n", - "emb_val_loss_log = []\n", - "clas_train_loss_log = []\n", - "clas_val_loss_log = []\n", - "train_accuracy_log = []\n", - "val_accuracy_log = []\n", - "train_ROC_AUC_log = []\n", - "val_ROC_AUC_log = []\n", - "train_AP_score_log = []\n", - "val_AP_score_log = []\n", - "\n", - "print(\"\\n--- Starting Training ---\")\n", - "for epoch in range(1, NUM_EPOCHS + 1):#NUM_EPOCHS\n", - " # Train\n", - " print(f\"\\n==== Training Epoch {epoch} ====\")\n", - " emb_train_loss, class_train_loss, train_acc, train_auc, train_aps = train_epoch(model, train_loader, criterion, classifier_crit, optimizer, scheduler, device)\n", - "\n", - " print(f\"Epoch {epoch} training finished.\")\n", - " print(f\"Average Training Embedding Loss: {emb_train_loss:.4f}\")\n", - " print(f\"Average Training Classification Loss: {class_train_loss:.4f}\")\n", - " print(f\"Training Classification Accuracy: {train_acc:.4f}\")\n", - " print(f\"Training ROC AUC: {train_auc:.4f}\")\n", - " print(f\"Training Average Precision Score: {train_aps:.4f}\")\n", - "\n", - " emb_train_loss_log.append(emb_train_loss)\n", - " clas_train_loss_log.append(class_train_loss)\n", - " train_accuracy_log.append(train_acc)\n", - " train_ROC_AUC_log.append(train_auc)\n", - " train_AP_score_log.append(train_aps)\n", - " \n", - " # Evaluate\n", - " emb_val_loss, class_val_loss, val_acc, val_auc, val_aps = evaluate(model, val_loader, criterion, classifier_crit, device)\n", - " \n", - " print(\"--- Validation phase ---\")\n", - " print(f\"Average Validation Embedding Loss: {emb_val_loss:.4f}\")\n", - " print(f\"Average Validation Classification Loss: {class_val_loss:.4f}\")\n", - " print(f\"Validation Classification Accuracy: {val_acc:.4f}\")\n", - " print(f\"Validation ROC AUC: {val_auc:.4f}\")\n", - " print(f\"Validation Average Precision Score: {val_aps:.4f}\")\n", - "\n", - " emb_val_loss_log.append(emb_val_loss)\n", - " clas_val_loss_log.append(class_val_loss)\n", - " val_accuracy_log.append(val_acc)\n", - " val_ROC_AUC_log.append(val_auc)\n", - " val_AP_score_log.append(val_aps)\n", - "\n", - " # Save best model\n", - " if val_aps > best_val_AP_score:\n", - " print(f\"Previous best average precision score: {best_val_AP_score:.4f}\")\n", - " best_val_AP_score = val_aps\n", - " print(\"Saving best model...\")\n", - " torch.save(model.state_dict(), (Path(DATA_ROOT) / 'best_siamese_model.pth'))\n", - " \n", - "print(\"\\n--- Training Finished ---\")\n", - "print(f\"Best Validation Average Precision Score: {best_val_AP_score:.4f}%\")" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "00c9d993", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10, 5))\n", - "\n", - "plt.subplot(1, 2, 1)\n", - "plt.plot(range(NUM_EPOCHS), emb_train_loss_log, label='Train Loss', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), emb_val_loss_log, label='Validation Loss', color='#384860')\n", - "plt.title('Embedding Loss over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('Loss')\n", - "plt.legend()\n", - "\n", - "plt.subplot(1, 2, 2)\n", - "plt.plot(range(NUM_EPOCHS), clas_train_loss_log, label='Train Loss', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), clas_val_loss_log, label='Validation Loss', color='#384860')\n", - "plt.title('Classification Loss over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('Loss')\n", - "plt.legend()\n", - "\n", - "plt.tight_layout()\n", - "plt.savefig('loss_logs.png')\n", - "plt.show()\n", - "#plt.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "eecbe86e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(15, 5))\n", - "\n", - "plt.subplot(1, 3, 1)\n", - "plt.plot(range(NUM_EPOCHS), train_accuracy_log, label='Train Accuracy', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), val_accuracy_log, label='Validation Accuracy', color='#384860')\n", - "plt.title('Classification Accuracy over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('Accuracy')\n", - "plt.legend()\n", - "\n", - "plt.subplot(1, 3, 2)\n", - "plt.plot(range(NUM_EPOCHS), train_ROC_AUC_log, label='Train ROC AUC', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), val_ROC_AUC_log, label='Validation ROC AUC', color='#384860')\n", - "plt.title('ROC AUC over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('ROC AUC')\n", - "plt.legend()\n", - "\n", - "plt.subplot(1, 3, 3)\n", - "plt.plot(range(NUM_EPOCHS), train_AP_score_log, label='Train AP Score', color='#97a6c4')\n", - "plt.plot(range(NUM_EPOCHS), val_AP_score_log, label='Validation AP Score', color='#384860')\n", - "plt.title('Average Precision Score over Epochs')\n", - "plt.xlabel('Epochs')\n", - "plt.ylabel('AP Score')\n", - "plt.legend()\n", - "\n", - "plt.tight_layout()\n", - "plt.savefig('metrics_logs.png')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "3e9f4d16", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.load_state_dict(torch.load((Path(DATA_ROOT) / 'best_siamese_model.pth')))" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "45c3f711", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
isic_idpatient_idtarget
0ISIC_2194940IP_32817660
1ISIC_6851122IP_20109190
2ISIC_0338723IP_06398770
3ISIC_0594289IP_36586070
4ISIC_8892018IP_21079930
............
111ISIC_9583969IP_42811941
112ISIC_9596721IP_07250271
113ISIC_9821002IP_50637561
114ISIC_9955163IP_75072121
115ISIC_9998682IP_25161681
\n", - "

116 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " isic_id patient_id target\n", - "0 ISIC_2194940 IP_3281766 0\n", - "1 ISIC_6851122 IP_2010919 0\n", - "2 ISIC_0338723 IP_0639877 0\n", - "3 ISIC_0594289 IP_3658607 0\n", - "4 ISIC_8892018 IP_2107993 0\n", - ".. ... ... ...\n", - "111 ISIC_9583969 IP_4281194 1\n", - "112 ISIC_9596721 IP_0725027 1\n", - "113 ISIC_9821002 IP_5063756 1\n", - "114 ISIC_9955163 IP_7507212 1\n", - "115 ISIC_9998682 IP_2516168 1\n", - "\n", - "[116 rows x 3 columns]" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "test_samples_subset = test_samples[test_samples[\"target\"]== 0].sample(n=58)\n", - "test_samples_subset = pd.concat([test_samples_subset, test_samples[test_samples[\"target\"]== 1]], ignore_index=True)\n", - "test_samples_subset" - ] - }, - { - "cell_type": "code", - "execution_count": 85, - "id": "e8530595", - "metadata": {}, - "outputs": [], - "source": [ - "test_dataset = SkinDataset(DATA_ROOT, test_samples, transform=None)\n", - "test_loader = DataLoader(test_dataset, batch_size=256, shuffle=True, num_workers=0)" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "id": "cb5d1533", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Test Classification Accuracy: 0.8539\n", - "Test ROC AUC: 0.8573\n", - "Test Average Precision Score: 0.1503\n", - "Test Sensitivity: 0.6034\n", - "Test Specificity: 0.8584\n" - ] - } - ], - "source": [ - "from sklearn.metrics import roc_auc_score, accuracy_score, average_precision_score, confusion_matrix\n", - "model.eval()\n", - "with torch.no_grad():\n", - " test_all_labels = []\n", - " test_all_embeds = []\n", - " test_all_predictions = []\n", - " test_all_probs = []\n", - " for i, (images, labels) in enumerate(test_loader):\n", - " images = images.to(device)\n", - "\n", - " # Get embeddings\n", - " embeddings = model(images)\n", - "\n", - " # classify embeddings\n", - " output = model.classify(embeddings)\n", - "\n", - " # Predictions and Probabilities\n", - " _, preds = torch.max(output, 1)\n", - " probs = torch.softmax(output, dim=1)[:, 1] # Probability of class 1 (Melanoma)\n", - " test_all_labels.extend(labels.cpu().numpy())\n", - " test_all_embeds.extend(embeddings.cpu().numpy())\n", - " test_all_predictions.extend(preds.cpu().numpy())\n", - " test_all_probs.extend(probs.cpu().numpy())\n", - "\n", - " test_acc = accuracy_score(test_all_labels, test_all_predictions)\n", - " test_auc = roc_auc_score(test_all_labels, test_all_probs)\n", - " test_aps = average_precision_score(test_all_labels, test_all_probs)\n", - " conf_matrix = confusion_matrix(test_all_labels, test_all_predictions)\n", - " tn, fp, fn, tp = conf_matrix.ravel()\n", - " sensitivity = tp / (tp + fn)\n", - " specificity = tn / (tn + fp)\n", - "\n", - " print(f\"Test Classification Accuracy: {test_acc:.4f}\")\n", - " print(f\"Test ROC AUC: {test_auc:.4f}\")\n", - " print(f\"Test Average Precision Score: {test_aps:.4f}\")\n", - " print(f\"Test Sensitivity: {sensitivity:.4f}\")\n", - " print(f\"Test Specificity: {specificity:.4f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "id": "60705bf6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2794 461 23 35\n" - ] - } - ], - "source": [ - "print(tn, fp, fn, tp)" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "id": "baadf2e9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix\n", - "cm = confusion_matrix(test_all_labels, test_all_predictions)\n", - "cm_display = ConfusionMatrixDisplay(cm).plot(cmap=\"Blues\")" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "id": "82428b82", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from sklearn.metrics import RocCurveDisplay, roc_curve, PrecisionRecallDisplay, precision_recall_curve\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n", - "fpr, tpr, _ = roc_curve(test_all_labels, test_all_probs)\n", - "roc_display = RocCurveDisplay(fpr=fpr, tpr=tpr).plot(ax=ax1)\n", - "ax1.set_title(\"ROC curve\")\n", - "\n", - "prec, recall, _ = precision_recall_curve(test_all_labels, test_all_probs)\n", - "pr_display = PrecisionRecallDisplay(precision=prec, recall=recall).plot(ax=ax2)\n", - "ax2.set_title(\"Precision-Recall curve\")\n", - "\n", - "plt.tight_layout()\n", - "#plt.savefig('loss_logs.png')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "id": "69be06b4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 't-SNE visualization of embeddings')" - ] - }, - "execution_count": 90, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from sklearn.manifold import TSNE\n", - "\n", - "tsne = TSNE(n_components=2, random_state=42)\n", - "embeddings_2d = tsne.fit_transform(np.array(test_all_embeds))\n", - "\n", - "plt.figure(figsize=(8, 6))\n", - "scatter = plt.scatter(np.array(test_all_embeds)[:, 0], np.array(test_all_embeds)[:, 1], c=np.array(test_all_labels), cmap='cividis')\n", - "plt.colorbar(scatter)\n", - "plt.title('t-SNE visualization of embeddings')\n", - "#plt.savefig('testing_tsne_embeddings.png')\n", - "#plt.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "d316ab2a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "--- Training Networks ---\n", - "\n", - "==== Training Epoch 1 ====\n", - "1.4105521440505981 90.27533721923828 0.6941325664520264 44.42448425292969\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n", - "nan nan nan nan\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[35]\u001b[39m\u001b[32m, line 67\u001b[39m\n\u001b[32m 63\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33m==== Training Epoch \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m ====\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 65\u001b[39m \u001b[38;5;66;03m# --- Training phase ----\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m67\u001b[39m \u001b[43m\u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mimages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43menumerate\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrain_loader\u001b[49m\u001b[43m)\u001b[49m\u001b[43m:\u001b[49m\n\u001b[32m 68\u001b[39m \u001b[43m \u001b[49m\u001b[43mimages\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m \u001b[49m\u001b[43m=\u001b[49m\u001b[43m \u001b[49m\u001b[43mimages\u001b[49m\u001b[43m.\u001b[49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabels\u001b[49m\u001b[43m.\u001b[49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 69\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m#print(i)\u001b[39;49;00m\n\u001b[32m 70\u001b[39m \n\u001b[32m 71\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# ---- Embedding model training ----\u001b[39;49;00m\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\utils\\data\\dataloader.py:734\u001b[39m, in \u001b[36m_BaseDataLoaderIter.__next__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 731\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._sampler_iter \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 732\u001b[39m \u001b[38;5;66;03m# TODO(https://github.com/pytorch/pytorch/issues/76750)\u001b[39;00m\n\u001b[32m 733\u001b[39m \u001b[38;5;28mself\u001b[39m._reset() \u001b[38;5;66;03m# type: ignore[call-arg]\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m734\u001b[39m data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_next_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 735\u001b[39m \u001b[38;5;28mself\u001b[39m._num_yielded += \u001b[32m1\u001b[39m\n\u001b[32m 736\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[32m 737\u001b[39m \u001b[38;5;28mself\u001b[39m._dataset_kind == _DatasetKind.Iterable\n\u001b[32m 738\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._IterableDataset_len_called \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 739\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._num_yielded > \u001b[38;5;28mself\u001b[39m._IterableDataset_len_called\n\u001b[32m 740\u001b[39m ):\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\utils\\data\\dataloader.py:790\u001b[39m, in \u001b[36m_SingleProcessDataLoaderIter._next_data\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 788\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_next_data\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 789\u001b[39m index = \u001b[38;5;28mself\u001b[39m._next_index() \u001b[38;5;66;03m# may raise StopIteration\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m790\u001b[39m data = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_dataset_fetcher\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfetch\u001b[49m\u001b[43m(\u001b[49m\u001b[43mindex\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# may raise StopIteration\u001b[39;00m\n\u001b[32m 791\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._pin_memory:\n\u001b[32m 792\u001b[39m data = _utils.pin_memory.pin_memory(data, \u001b[38;5;28mself\u001b[39m._pin_memory_device)\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\utils\\data\\_utils\\fetch.py:52\u001b[39m, in \u001b[36m_MapDatasetFetcher.fetch\u001b[39m\u001b[34m(self, possibly_batched_index)\u001b[39m\n\u001b[32m 50\u001b[39m data = \u001b[38;5;28mself\u001b[39m.dataset.__getitems__(possibly_batched_index)\n\u001b[32m 51\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m52\u001b[39m data = [\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mdataset\u001b[49m\u001b[43m[\u001b[49m\u001b[43midx\u001b[49m\u001b[43m]\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m idx \u001b[38;5;129;01min\u001b[39;00m possibly_batched_index]\n\u001b[32m 53\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 54\u001b[39m data = \u001b[38;5;28mself\u001b[39m.dataset[possibly_batched_index]\n", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 37\u001b[39m, in \u001b[36mSkinDataset.__getitem__\u001b[39m\u001b[34m(self, idx)\u001b[39m\n\u001b[32m 35\u001b[39m image = Image.open(\u001b[38;5;28mself\u001b[39m.image_dir / (image_name + \u001b[33m\"\u001b[39m\u001b[33m.jpg\u001b[39m\u001b[33m\"\u001b[39m)).convert(\u001b[33m'\u001b[39m\u001b[33mRGB\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m 36\u001b[39m \u001b[38;5;66;03m# Transform image\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m37\u001b[39m image = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 39\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m image, torch.tensor(label, dtype=torch.long)\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\transforms\\transforms.py:95\u001b[39m, in \u001b[36mCompose.__call__\u001b[39m\u001b[34m(self, img)\u001b[39m\n\u001b[32m 93\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__call__\u001b[39m(\u001b[38;5;28mself\u001b[39m, img):\n\u001b[32m 94\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m t \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.transforms:\n\u001b[32m---> \u001b[39m\u001b[32m95\u001b[39m img = \u001b[43mt\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 96\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m img\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1773\u001b[39m, in \u001b[36mModule._wrapped_call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 1771\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._compiled_call_impl(*args, **kwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[32m 1772\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1773\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1784\u001b[39m, in \u001b[36mModule._call_impl\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 1779\u001b[39m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[32m 1780\u001b[39m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[32m 1781\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m._backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m._forward_pre_hooks\n\u001b[32m 1782\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[32m 1783\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[32m-> \u001b[39m\u001b[32m1784\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1786\u001b[39m result = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m 1787\u001b[39m called_always_called_hooks = \u001b[38;5;28mset\u001b[39m()\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\transforms\\transforms.py:1280\u001b[39m, in \u001b[36mColorJitter.forward\u001b[39m\u001b[34m(self, img)\u001b[39m\n\u001b[32m 1278\u001b[39m img = F.adjust_saturation(img, saturation_factor)\n\u001b[32m 1279\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m fn_id == \u001b[32m3\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m hue_factor \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m1280\u001b[39m img = \u001b[43mF\u001b[49m\u001b[43m.\u001b[49m\u001b[43madjust_hue\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhue_factor\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1282\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m img\n", - "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\melis\\miniconda3\\envs\\torch\\Lib\\site-packages\\torchvision\\transforms\\functional.py:934\u001b[39m, in \u001b[36madjust_hue\u001b[39m\u001b[34m(img, hue_factor)\u001b[39m\n\u001b[32m 929\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m F_pil.adjust_saturation(img, saturation_factor)\n\u001b[32m 931\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m F_t.adjust_saturation(img, saturation_factor)\n\u001b[32m--> \u001b[39m\u001b[32m934\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34madjust_hue\u001b[39m(img: Tensor, hue_factor: \u001b[38;5;28mfloat\u001b[39m) -> Tensor:\n\u001b[32m 935\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Adjust hue of an image.\u001b[39;00m\n\u001b[32m 936\u001b[39m \n\u001b[32m 937\u001b[39m \u001b[33;03m The image hue is adjusted by converting the image to HSV and\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 963\u001b[39m \u001b[33;03m PIL Image or Tensor: Hue adjusted image.\u001b[39;00m\n\u001b[32m 964\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m 965\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m torch.jit.is_scripting() \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m torch.jit.is_tracing():\n", - "\u001b[31mKeyboardInterrupt\u001b[39m: " - ] - } - ], - "source": [ - "train_samples, val_samples, test_samples = split_data(DATA_ROOT)\n", - "\n", - "train_dataset = SkinDataset(DATA_ROOT, \n", - " train_samples,\n", - " transform=transforms.Compose([\n", - " transforms.RandomRotation(degrees=15, fill=(255, 255, 255)),\n", - " transforms.RandomHorizontalFlip(p=0.5),\n", - " transforms.RandomVerticalFlip(p=0.5),\n", - " transforms.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.05)\n", - " ]))\n", - "\n", - "val_dataset = SkinDataset(DATA_ROOT, val_samples, transform=None)\n", - "\n", - "# Use standard DataLoader; Triplet mining is handled in the custom loss\n", - "train_loader = DataLoader(train_dataset, batch_size=TRAIN_BATCH_SIZE, shuffle=True, drop_last=True, num_workers=0)\n", - "val_loader = DataLoader(val_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=0)\n", - "\n", - "# Model Setup\n", - "\n", - "# Embedding Net with Triplet Loss\n", - "embedding_net = EmbeddingNet(image_size=IMAGE_SIZE, out_dim=EMBEDDING_DIM).to(device)\n", - "embedding_crit = TripletMarginLoss(margin=MARGIN)\n", - "embedding_opt = optim.Adam(embedding_net.parameters(), lr=LEARNING_RATE)\n", - "scheduler = optim.lr_scheduler.ReduceLROnPlateau(embedding_opt, mode='max', factor=0.5, patience=5)\n", - "\n", - "# Classification Head with Cross-Entropy Loss\n", - "classifier_net = ClassificationNet(EMBEDDING_DIM).to(device)\n", - "classifier_crit = nn.CrossEntropyLoss().to(device)\n", - "classifier_opt = optim.Adam(classifier_net.parameters(), lr=LEARNING_RATE)# * 5) # Faster learning rate for small head\n", - "\n", - "epochs = NUM_EPOCHS\n", - "#train_nets(\n", - "# embedding_net, classifier_head, \n", - "# train_loader, val_loader, \n", - "# triplet_criterion, classification_criterion, \n", - "# embedding_optimizer, classifier_optimizer, \n", - "# embedding_scheduler,\n", - "# NUM_EPOCHS, \n", - "# device)\n", - "\n", - "\n", - "\n", - "print(\"\\n--- Training Networks ---\")\n", - "\n", - "# metric logging intialisation\n", - "best_val_ROC_AUC = -1.0\n", - "emb_train_loss_log = []\n", - "clas_train_loss_log = []\n", - "train_accuracy_log = []\n", - "emb_val_loss_log = []\n", - "clas_val_loss_log = []\n", - "val_accuracy_log = []\n", - "val_ROC_AUC_log = []\n", - "\n", - "for epoch in range(1, epochs + 1):\n", - " embedding_net.train()\n", - " classifier_net.train()\n", - " emb_running_loss = 0.0\n", - " clas_running_loss = 0.0\n", - " correct_predictions = 0\n", - " total_samples = 0\n", - "\n", - " print(f\"\\n==== Training Epoch {epoch} ====\")\n", - "\n", - " # --- Training phase ----\n", - "\n", - " for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - " #print(i)\n", - "\n", - " # ---- Embedding model training ----\n", - " \n", - " embedding_opt.zero_grad()\n", - " classifier_opt.zero_grad()\n", - " # Generate embeddings\n", - " embeddings = embedding_net(images)\n", - " \n", - " # Calculate Triplet Loss using Batch-Hard mining\n", - " emb_loss = embedding_crit(embeddings, labels)\n", - " \n", - " # ---- Classification model training ----\n", - " \n", - " \n", - " # Classify\n", - " outputs = classifier_net(embeddings)\n", - " clas_loss = classifier_crit(outputs, labels)\n", - "\n", - " # Statistics\n", - " emb_running_loss += emb_loss.item() * len(images)\n", - " clas_running_loss += clas_loss.item() * len(images)\n", - " _, preds = torch.max(outputs, 1)\n", - " correct_predictions += torch.sum(preds == labels.data).item()\n", - " total_samples += len(images)\n", - "\n", - " print(emb_loss.item(), emb_running_loss, clas_loss.item(), clas_running_loss)\n", - " if (i + 1) % 50 == 0:\n", - " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_loss.item()):.4f}, Classification training loss: {(clas_loss.item()):.4f}')\n", - " #print(clas_loss)\n", - "\n", - " total_loss = emb_loss + clas_loss\n", - "\n", - " \n", - " total_loss.backward()\n", - " embedding_opt.step()\n", - " classifier_opt.step()\n", - "\n", - " # embedding training epoch loss\n", - " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", - " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", - "\n", - " # classification training epoch loss\n", - " clas_epoch_loss = clas_running_loss / total_samples\n", - " epoch_acc = correct_predictions / total_samples\n", - " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", - " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", - "\n", - " # ---- Evaluation phase ----\n", - "\n", - " print(\"--- Validation phase ---\")\n", - " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", - " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", - " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", - " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", - " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", - "\n", - " # metric logging for plotting\n", - " emb_train_loss_log.append(emb_epoch_loss)\n", - " clas_train_loss_log.append(clas_epoch_loss)\n", - " train_accuracy_log.append(epoch_acc)\n", - " emb_val_loss_log.append(val_emb_loss)\n", - " clas_val_loss_log.append(val_clas_loss)\n", - " val_accuracy_log.append(epoch_val_accuracy)\n", - " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", - "\n", - " scheduler.step(epoch_val_ROC_AUC)\n", - "\n", - " # save best model based on ROC AUC\n", - " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", - " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", - " best_val_ROC_AUC = epoch_val_ROC_AUC\n", - " # Save model checkpoint\n", - " print(\"Saving best model...\")\n", - " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", - " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", - "\n", - "\n", - "print(\"Network training complete.\")\n", - "\n", - "# Graphical display of metric logs\n", - "plot_logs(\n", - " emb_train_loss_log, \n", - " clas_train_loss_log,\n", - " train_accuracy_log,\n", - " emb_val_loss_log,\n", - " clas_val_loss_log,\n", - " val_accuracy_log,\n", - " val_ROC_AUC_log,\n", - " epochs)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "911f3e5c", - "metadata": {}, - "outputs": [], - "source": [ - "# metric logging intialisation\n", - "best_val_ROC_AUC = -1.0\n", - "emb_train_loss_log = []\n", - "clas_train_loss_log = []\n", - "train_accuracy_log = []\n", - "emb_val_loss_log = []\n", - "clas_val_loss_log = []\n", - "val_accuracy_log = []\n", - "val_ROC_AUC_log = []" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "4fda77d1", - "metadata": {}, - "outputs": [], - "source": [ - "embedding_net.train()\n", - "classifier_head.train()\n", - "emb_running_loss = 0.0\n", - "clas_running_loss = 0.0\n", - "correct_predictions = 0\n", - "total_samples = 0" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "572a2cb9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([[[[2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " ...,\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", - "\n", - " [[2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " ...,\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", - "\n", - " [[2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " ...,\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", - "\n", - "\n", - " [[[2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", - " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", - " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", - " ...,\n", - " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", - " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948],\n", - " [2.0948, 2.0948, 2.0948, ..., 2.0948, 2.0948, 2.0948]],\n", - "\n", - " [[2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", - " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", - " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", - " ...,\n", - " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", - " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710],\n", - " [2.2710, 2.2710, 2.2710, ..., 2.2710, 2.2710, 2.2710]],\n", - "\n", - " [[2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", - " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", - " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", - " ...,\n", - " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", - " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831],\n", - " [2.4831, 2.4831, 2.4831, ..., 2.4831, 2.4831, 2.4831]]],\n", - "\n", - "\n", - " [[[2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " ...,\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", - "\n", - " [[2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " ...,\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", - "\n", - " [[2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " ...,\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", - "\n", - "\n", - " ...,\n", - "\n", - "\n", - " [[[2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " ...,\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", - "\n", - " [[2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " ...,\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", - "\n", - " [[2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " ...,\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", - "\n", - "\n", - " [[[2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", - " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", - " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", - " ...,\n", - " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", - " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605],\n", - " [2.0605, 2.0605, 2.0605, ..., 2.0605, 2.0605, 2.0605]],\n", - "\n", - " [[2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", - " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", - " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", - " ...,\n", - " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", - " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360],\n", - " [2.2360, 2.2360, 2.2360, ..., 2.2360, 2.2360, 2.2360]],\n", - "\n", - " [[2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", - " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", - " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", - " ...,\n", - " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", - " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483],\n", - " [2.4483, 2.4483, 2.4483, ..., 2.4483, 2.4483, 2.4483]]],\n", - "\n", - "\n", - " [[[1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", - " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", - " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", - " ...,\n", - " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", - " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920],\n", - " [1.9920, 1.9920, 1.9920, ..., 1.9920, 1.9920, 1.9920]],\n", - "\n", - " [[2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", - " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", - " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", - " ...,\n", - " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", - " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660],\n", - " [2.1660, 2.1660, 2.1660, ..., 2.1660, 2.1660, 2.1660]],\n", - "\n", - " [[2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", - " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", - " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", - " ...,\n", - " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", - " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786],\n", - " [2.3786, 2.3786, 2.3786, ..., 2.3786, 2.3786, 2.3786]]]],\n", - " device='cuda:0')\n", - "tensor([0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0,\n", - " 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1,\n", - " 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0], device='cuda:0')\n" - ] - } - ], - "source": [ - "for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - " if i == 0:\n", - " break\n", - "\n", - "print(images)\n", - "print(labels)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "b8fcc614", - "metadata": {}, - "outputs": [], - "source": [ - "embeddings = embedding_net(images)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "c4aef745", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Size([64, 3, 256, 256])" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "images.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "8ed15396", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "torch.Size([64, 128])" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "embeddings.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "07b488b6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " ...,\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]], device='cuda:0',\n", - " grad_fn=)" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "embeddings" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "59739384", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(nan, device='cuda:0', grad_fn=)" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "emb_loss = triplet_criterion(embeddings, labels)\n", - "emb_loss" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "0b1762df", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[ 0.0479, 0.0744],\n", - " [ 0.0237, 0.0800],\n", - " [ 0.0478, 0.0973],\n", - " [ 0.0512, 0.0786],\n", - " [ 0.0393, 0.0880],\n", - " [ 0.0464, 0.0743],\n", - " [ 0.0111, 0.0674],\n", - " [ 0.0576, 0.0923],\n", - " [ 0.0611, 0.0609],\n", - " [ 0.0347, 0.0788],\n", - " [ 0.0382, 0.0774],\n", - " [ 0.0160, 0.0872],\n", - " [ 0.0551, 0.0697],\n", - " [ 0.0494, 0.0631],\n", - " [ 0.0715, 0.1054],\n", - " [-0.0108, 0.1196],\n", - " [ 0.0299, 0.0603],\n", - " [ 0.0239, 0.0684],\n", - " [ 0.0194, 0.0501],\n", - " [ 0.0075, 0.0995],\n", - " [ 0.0670, 0.0818],\n", - " [ 0.0594, 0.0578],\n", - " [ 0.0174, 0.0901],\n", - " [ 0.0020, 0.0933],\n", - " [ 0.0479, 0.0772],\n", - " [ 0.0612, 0.0842],\n", - " [ 0.0027, 0.1050],\n", - " [ 0.0487, 0.0947],\n", - " [ 0.0326, 0.0844],\n", - " [ 0.0397, 0.0907],\n", - " [ 0.0308, 0.0724],\n", - " [ 0.0506, 0.0829],\n", - " [ 0.0544, 0.0757],\n", - " [ 0.0558, 0.0805],\n", - " [ 0.0114, 0.0966],\n", - " [ 0.0361, 0.0870],\n", - " [ 0.0213, 0.0906],\n", - " [ 0.0905, 0.0480],\n", - " [ 0.0082, 0.0884],\n", - " [ 0.0314, 0.0645],\n", - " [ 0.0432, 0.0466],\n", - " [ 0.0586, 0.0866],\n", - " [-0.0045, 0.1095],\n", - " [ 0.0022, 0.0987],\n", - " [ 0.0414, 0.0694],\n", - " [ 0.0769, 0.1061],\n", - " [ 0.0336, 0.0895],\n", - " [ 0.0678, 0.0643],\n", - " [ 0.0106, 0.0814],\n", - " [ 0.0381, 0.0939],\n", - " [ 0.0455, 0.0872],\n", - " [ 0.0064, 0.0452],\n", - " [ 0.0548, 0.0828],\n", - " [ 0.0405, 0.0589],\n", - " [ 0.0530, 0.0502],\n", - " [ 0.0582, 0.0994],\n", - " [ 0.0433, 0.0711],\n", - " [ 0.0754, 0.0575],\n", - " [ 0.0006, 0.1162],\n", - " [ 0.0466, 0.0540],\n", - " [ 0.0253, 0.0630],\n", - " [ 0.0507, 0.0666],\n", - " [ 0.0447, 0.0542],\n", - " [ 0.0651, 0.0899]], device='cuda:0', grad_fn=)" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "outputs = classifier_head(embeddings)\n", - "outputs" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "4e076c91", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(0.6934, device='cuda:0', grad_fn=)" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "clas_loss = classification_criterion(outputs, labels)\n", - "clas_loss" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "423f1f54", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "87.67748260498047" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "emb_running_loss += emb_loss.item() * len(images)\n", - "emb_running_loss" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "846b1c0d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "44.377403259277344" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "clas_running_loss += clas_loss.item() * len(images)\n", - "clas_running_loss" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "8f2a3fb1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "29" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "_, preds = torch.max(outputs, 1)\n", - "correct_predictions += torch.sum(preds == labels.data).item()\n", - "total_samples += len(images)\n", - "correct_predictions" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "448d3126", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch , Batch 1/813, Embedding training loss: 1.3700, Classification training loss: 0.6934\n" - ] - } - ], - "source": [ - "print(f'Epoch , Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_running_loss/total_samples):.4f}, Classification training loss: {(clas_running_loss/total_samples):.4f}')" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "fac26663", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(2.0634, device='cuda:0', grad_fn=)" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "total_loss = emb_loss + clas_loss\n", - "total_loss" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "ef1ceb73", - "metadata": {}, - "outputs": [], - "source": [ - "embedding_optimizer.zero_grad()\n", - "classifier_optimizer.zero_grad()\n", - "total_loss.backward()\n", - "embedding_optimizer.step()\n", - "classifier_optimizer.step()" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "4f2b2b3a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([[[[ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " ...,\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", - "\n", - " [[ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " ...,\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", - "\n", - " [[ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " ...,\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", - "\n", - "\n", - " [[[ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " ...,\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", - "\n", - " [[ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " ...,\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", - "\n", - " [[ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " ...,\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", - "\n", - "\n", - " [[[ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " ...,\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", - "\n", - " [[ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " ...,\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", - "\n", - " [[ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " ...,\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", - "\n", - "\n", - " ...,\n", - "\n", - "\n", - " [[[ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " ...,\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489],\n", - " [ 2.2489, 2.2489, 2.2489, ..., 2.2489, 2.2489, 2.2489]],\n", - "\n", - " [[ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " ...,\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286],\n", - " [ 2.4286, 2.4286, 2.4286, ..., 2.4286, 2.4286, 2.4286]],\n", - "\n", - " [[ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " ...,\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400],\n", - " [ 2.6400, 2.6400, 2.6400, ..., 2.6400, 2.6400, 2.6400]]],\n", - "\n", - "\n", - " [[[ 2.2318, 1.5468, 1.5297, ..., 2.2318, 2.2318, 2.2318],\n", - " [ 2.2318, 1.5297, 1.5297, ..., 0.8447, 0.8618, 0.8276],\n", - " [ 2.2318, 1.5297, 1.5297, ..., 0.8961, 0.9303, 0.8961],\n", - " ...,\n", - " [ 1.1015, 1.1529, 1.1529, ..., 1.4783, 1.4783, 2.2318],\n", - " [ 1.1187, 1.1187, 1.1358, ..., 1.4612, 1.4612, 2.2318],\n", - " [ 2.2318, 2.2318, 2.2318, ..., 1.4269, 1.4269, 2.2318]],\n", - "\n", - " [[ 2.4111, 0.9230, 0.9055, ..., 2.4111, 2.4111, 2.4111],\n", - " [ 2.4111, 0.9055, 0.9055, ..., -0.0574, -0.0224, 0.0301],\n", - " [ 2.4111, 0.9055, 0.9055, ..., 0.0126, 0.0126, 0.1001],\n", - " ...,\n", - " [ 0.1001, 0.1702, 0.1702, ..., 0.5553, 0.5553, 2.4111],\n", - " [ 0.1352, 0.1352, 0.1352, ..., 0.5378, 0.5378, 2.4111],\n", - " [ 2.4111, 2.4111, 2.4111, ..., 0.5203, 0.5203, 2.4111]],\n", - "\n", - " [[ 2.6226, 1.1411, 1.1237, ..., 2.6226, 2.6226, 2.6226],\n", - " [ 2.6226, 1.1237, 1.1237, ..., 0.1651, 0.1999, 0.1999],\n", - " [ 2.6226, 1.1237, 1.1237, ..., 0.2348, 0.2348, 0.2696],\n", - " ...,\n", - " [ 0.2173, 0.2696, 0.2696, ..., 0.7402, 0.7402, 2.6226],\n", - " [ 0.2348, 0.2348, 0.2522, ..., 0.7402, 0.7402, 2.6226],\n", - " [ 2.6226, 2.6226, 2.6226, ..., 0.7228, 0.7228, 2.6226]]],\n", - "\n", - "\n", - " [[[ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", - " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", - " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", - " ...,\n", - " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", - " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777],\n", - " [ 2.0777, 2.0777, 2.0777, ..., 2.0777, 2.0777, 2.0777]],\n", - "\n", - " [[ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", - " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", - " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", - " ...,\n", - " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", - " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535],\n", - " [ 2.2535, 2.2535, 2.2535, ..., 2.2535, 2.2535, 2.2535]],\n", - "\n", - " [[ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", - " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", - " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", - " ...,\n", - " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", - " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657],\n", - " [ 2.4657, 2.4657, 2.4657, ..., 2.4657, 2.4657, 2.4657]]]],\n", - " device='cuda:0')\n", - "tensor([1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1,\n", - " 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0,\n", - " 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1], device='cuda:0')\n" - ] - } - ], - "source": [ - "for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - " if i == 0:\n", - " break\n", - "\n", - "print(images)\n", - "print(labels)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7064b1d3", - "metadata": {}, - "outputs": [], - "source": [ - "def train_nets(\n", - " embedding_net, classifier_net, \n", - " train_loader, val_loader, \n", - " embedding_crit, classifier_crit, \n", - " embedding_opt, classifier_opt, \n", - " scheduler,\n", - " epochs, \n", - " device):\n", - " \"\"\"Trains the Siamese Embedding Network using Triplet Loss.\"\"\"\n", - " \n", - " print(\"\\n--- Training Networks ---\")\n", - "\n", - " # metric logging intialisation\n", - " best_val_ROC_AUC = -1.0\n", - " emb_train_loss_log = []\n", - " clas_train_loss_log = []\n", - " train_accuracy_log = []\n", - " emb_val_loss_log = []\n", - " clas_val_loss_log = []\n", - " val_accuracy_log = []\n", - " val_ROC_AUC_log = []\n", - " \n", - " for epoch in range(1, epochs + 1):\n", - " embedding_net.train()\n", - " classifier_net.train()\n", - " emb_running_loss = 0.0\n", - " clas_running_loss = 0.0\n", - " correct_predictions = 0\n", - " total_samples = 0\n", - "\n", - " print(f\"\\n==== Training Epoch {epoch} ====\")\n", - "\n", - " # --- Training phase ----\n", - "\n", - " for i, (images, labels) in enumerate(train_loader):\n", - " images, labels = images.to(device), labels.to(device)\n", - " #print(i)\n", - "\n", - " # ---- Embedding model training ----\n", - " \n", - " \n", - " # Generate embeddings\n", - " embeddings = embedding_net(images)\n", - " \n", - " # Calculate Triplet Loss using Batch-Hard mining\n", - " emb_loss = embedding_crit(embeddings, labels)\n", - " \n", - " # ---- Classification model training ----\n", - " \n", - " \n", - " # Classify\n", - " outputs = classifier_net(embeddings)\n", - " clas_loss = classifier_crit(outputs, labels)\n", - "\n", - " # Statistics\n", - " emb_running_loss += emb_loss.item() * len(images)\n", - " clas_running_loss += clas_loss.item() * len(images)\n", - " _, preds = torch.max(outputs, 1)\n", - " correct_predictions += torch.sum(preds == labels.data).item()\n", - " total_samples += len(images)\n", - "\n", - " if (i + 1) % 50 == 0:\n", - " print(f'Epoch {epoch}/{epochs}, Batch {i+1}/{len(train_loader)}, Embedding training loss: {(emb_running_loss/total_samples):.4f}, Classification training loss: {(clas_running_loss/total_samples):.4f}')\n", - " #print(clas_loss)\n", - "\n", - " total_loss = emb_loss + clas_loss\n", - "\n", - " embedding_opt.zero_grad()\n", - " classifier_opt.zero_grad()\n", - " total_loss.backward()\n", - " embedding_opt.step()\n", - " classifier_opt.step()\n", - "\n", - " # embedding training epoch loss\n", - " emb_epoch_loss = emb_running_loss / total_samples #len(train_loader.dataset)\n", - " print(f\"Epoch {epoch} finished. \\nAverage Training Embedding Loss: {emb_epoch_loss:.4f}\")\n", - "\n", - " # classification training epoch loss\n", - " clas_epoch_loss = clas_running_loss / total_samples\n", - " epoch_acc = correct_predictions / total_samples\n", - " print(f\"Average Training Classification Loss: {clas_epoch_loss:.4f}\")\n", - " print(f\"Training Classification Accuracy: {epoch_acc:.4f}\")\n", - "\n", - " # ---- Evaluation phase ----\n", - "\n", - " print(\"--- Validation phase ---\")\n", - " val_emb_loss, val_clas_loss, epoch_val_accuracy, epoch_val_ROC_AUC = evaluate_model(embedding_net, classifier_net, embedding_crit, classifier_crit, val_loader, device)\n", - " print(f\"Average Validation Embedding Loss: {val_emb_loss:.4f}\")\n", - " print(f\"Average Validation Classification Loss: {val_clas_loss:.4f}\")\n", - " print(f\"Validation Classification Accuracy: {epoch_val_accuracy:.4f}\")\n", - " print(f\"Validation ROC AUC: {epoch_val_ROC_AUC:.4f}\")\n", - "\n", - " # metric logging for plotting\n", - " emb_train_loss_log.append(emb_epoch_loss)\n", - " clas_train_loss_log.append(clas_epoch_loss)\n", - " train_accuracy_log.append(epoch_acc)\n", - " emb_val_loss_log.append(val_emb_loss)\n", - " clas_val_loss_log.append(val_clas_loss)\n", - " val_accuracy_log.append(epoch_val_accuracy)\n", - " val_ROC_AUC_log.append(epoch_val_ROC_AUC)\n", - "\n", - " scheduler.step(epoch_val_ROC_AUC)\n", - "\n", - " # save best model based on ROC AUC\n", - " if epoch_val_ROC_AUC > best_val_ROC_AUC:\n", - " print(f\"Previous best ROC AUC: {best_val_ROC_AUC:.4f}\")\n", - " best_val_ROC_AUC = epoch_val_ROC_AUC\n", - " # Save model checkpoint\n", - " print(\"Saving best model...\")\n", - " torch.save(embedding_net.state_dict(), Path(DATA_ROOT / 'best_embedding_model.pth'))\n", - " torch.save(classifier_net.state_dict(), Path(DATA_ROOT / 'best_classifier_model.pth'))\n", - "\n", - "\n", - " print(\"Network training complete.\")\n", - "\n", - " # Graphical display of metric logs\n", - " plot_logs(\n", - " emb_train_loss_log, \n", - " clas_train_loss_log,\n", - " train_accuracy_log,\n", - " emb_val_loss_log,\n", - " clas_val_loss_log,\n", - " val_accuracy_log,\n", - " val_ROC_AUC_log,\n", - " epochs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d4f83545", - "metadata": {}, - "outputs": [], - "source": [ - "# Evaluation\n", - "test_dataset = SkinDataset(DATA_ROOT, test_samples, transform=None)\n", - "val_loader = DataLoader(test_dataset, batch_size=VAL_TEST_BATCH_SIZE, shuffle=True, num_workers=0)\n", - "evaluate_model(embedding_net, classifier_head, val_loader, device)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "686dccd5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3313" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "512*6+241" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "9ba440ec", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3313" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(val_dataset)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "torch", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}