Update

augment.py

@@ -39,7 +39,6 @@ for task in ["1"]:
                 output_directory=f"{class_label}/",
                 save_format="png",
             )
-            p.rotate(probability=0.8, max_left_rotation=5, max_right_rotation=5)
             p.flip_left_right(probability=0.8)
             p.zoom_random(probability=0.8, percentage_area=0.8)
             p.flip_top_bottom(probability=0.8)

combine_dats.py

@@ -0,0 +1,42 @@
+# Copy the all the data from external, augmented and raw folders to combined folder
+import os
+import shutil
+import uuid
+
+from configs import *
+
+for disease in CLASSES:
+    # check if the original folder exists
+    if os.path.exists(RAW_DATA_DIR + '1/' + disease):
+        print("Copying raw data for disease: ", disease)
+        if not os.path.exists(COMBINED_DATA_DIR + '1/' + disease):
+            os.makedirs(COMBINED_DATA_DIR + '1/' + disease)
+        for file in os.listdir(RAW_DATA_DIR + '1/' + disease):
+            random_name = str(uuid.uuid4()) + ".png"
+            shutil.copy(
+                RAW_DATA_DIR + '1/' + disease + '/' + file,
+                COMBINED_DATA_DIR + '1/' + disease + '/' + random_name,
+            )
+        
+    if os.path.exists(EXTERNAL_DATA_DIR + '1/' + disease):
+        print("Copying external data for disease: ", disease)
+        if not os.path.exists(COMBINED_DATA_DIR + '1/' + disease):
+            os.makedirs(COMBINED_DATA_DIR + '1/' + disease)
+        for file in os.listdir(EXTERNAL_DATA_DIR + '1/' + disease):
+            random_name = str(uuid.uuid4()) + ".png"
+            shutil.copy(
+                EXTERNAL_DATA_DIR + '1/' + disease + '/' + file,
+                COMBINED_DATA_DIR + '1/' + disease + '/' + random_name,
+            )
+        
+    if os.path.exists(AUG_DATA_DIR + '1/' + disease):
+        print("Copying augmented data for disease: ", disease)
+        if not os.path.exists(COMBINED_DATA_DIR + '1/' + disease):
+            os.makedirs(COMBINED_DATA_DIR + '1/' + disease)
+        for file in os.listdir(AUG_DATA_DIR + '1/' + disease):
+            random_name = str(uuid.uuid4()) + ".png"
+            shutil.copy(
+                AUG_DATA_DIR + '1/' + disease + '/' + file,
+                COMBINED_DATA_DIR + '1/' + disease + '/' + random_name,
+            )
+    

configs.py

@@ -14,17 +14,18 @@ from torchvision.models import squeezenet1_0
 
 # Constants
 RANDOM_SEED = 123
-BATCH_SIZE = 16
+BATCH_SIZE = 64
 NUM_EPOCHS = 100
-LEARNING_RATE = 2.0950584442749585e-05
+LEARNING_RATE = 0.00016633192288673592
 STEP_SIZE = 10
-GAMMA = 0.5
+GAMMA = 0.9
 DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 NUM_PRINT = 100
 TASK = 1
 RAW_DATA_DIR = r"data/train/raw/Task "
 AUG_DATA_DIR = r"data/train/augmented/Task "
 EXTERNAL_DATA_DIR = r"data/train/external/Task "
+COMBINED_DATA_DIR = r"data/train/combined/Task "
 TEMP_DATA_DIR = "data/temp/"
 NUM_CLASSES = 7
 EARLY_STOPPING_PATIENCE = 20
@@ -108,7 +109,7 @@ class ResNet18WithNorm(nn.Module):
             nn.AdaptiveAvgPool2d((1, 1)),
             nn.Flatten(),
             nn.Linear(512, num_classes),
-            nn.BatchNorm2d(num_classes),  # Add batch normalization
+            nn.BatchNorm1d(num_classes),  # Add batch normalization
         )
 
     def forward(self, x):
@@ -123,7 +124,7 @@ print(CLASSES)
 
 preprocess = transforms.Compose(
     [
-        transforms.Resize((64, 64)),  # Resize images to 64x64
+        transforms.Resize((112, 112)), # Resize to 112x112
         transforms.ToTensor(),  # Convert to tensor
         transforms.Grayscale(num_output_channels=3),  # Convert to 3 channels
         # Normalize 3 channels

eda.py

@@ -0,0 +1,103 @@
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from matplotlib import rcParams
+
+rcParams['font.family'] = 'Times New Roman'
+
+# Define the directory where your dataset is located
+dataset_directory = 'data/train/combined/Task 1/'
+
+# Create a list of class labels based on subdirectories in the dataset directory
+class_labels = os.listdir(dataset_directory)
+
+# Initialize lists to store data for EDA
+num_samples_per_class = []
+class_labels_processed = []
+
+# Initialize an empty DataFrame to store image dimensions
+image_dimensions_df = pd.DataFrame(columns=['Height', 'Width'])
+
+# Initialize a dictionary to store a random sample of images from each class
+sampled_images = {label: [] for label in class_labels}
+
+# Iterate through class labels and count the number of samples per class
+for label in class_labels:
+    if label != ".DS_Store":
+        class_directory = os.path.join(dataset_directory, label)
+        num_samples = len(os.listdir(class_directory))
+        num_samples_per_class.append(num_samples)
+        class_labels_processed.append(label)
+        
+        # Extract image dimensions and add them to the DataFrame
+        for image_file in os.listdir(class_directory):
+            image_path = os.path.join(class_directory, image_file)
+            image = plt.imread(image_path)
+            height, width, _ = image.shape
+            image_dimensions_df = image_dimensions_df._append({'Height': height, 'Width': width}, ignore_index=True)
+            
+            # Randomly sample 5 images from each class for visualization
+            if len(sampled_images[label]) < 5:
+                sampled_images[label].append(image)
+
+# Create a Pandas DataFrame for EDA
+eda_data = pd.DataFrame({'Class Label': class_labels_processed, 'Number of Samples': num_samples_per_class})
+
+# Plot the number of samples per class
+plt.figure(figsize=(10, 6))
+sns.barplot(x='Class Label', y='Number of Samples', data=eda_data)
+plt.title('Number of Samples per Class')
+plt.xticks(rotation=45)
+plt.xlabel('Class Label')
+plt.ylabel('Number of Samples')
+plt.savefig('docs/eda/Number of Samples per Class.png')
+plt.show()
+
+# Calculate and plot the distribution of sample sizes (image dimensions)
+plt.figure(figsize=(10, 6))
+plt.scatter(image_dimensions_df['Width'], image_dimensions_df['Height'], alpha=0.5)
+plt.title('Distribution of Sample Sizes (Image Dimensions)')
+plt.xlabel('Width (Pixels)')
+plt.ylabel('Height (Pixels)')
+plt.savefig('docs/eda/Distribution of Sample Sizes (Image Dimensions).png')
+plt.show()
+
+# Plot a random sample of images from each class
+for label, images in sampled_images.items():
+    plt.figure(figsize=(15, 5))
+    plt.suptitle(f'Random Sample of Images from Class: {label}')
+    for i, image in enumerate(images, start=1):
+        plt.subplot(1, 5, i)
+        plt.imshow(image)
+        plt.axis('off')
+        plt.title(f'Sample {i}')
+    plt.savefig(f'docs/eda/Random Sample of Images from Class {label}.png')
+    plt.show()
+
+# Calculate and plot the correlation matrix for image dimensions
+correlation_matrix = image_dimensions_df.corr()
+plt.figure(figsize=(8, 6))
+sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', linewidths=0.5)
+plt.title('Correlation Matrix of Image Dimensions')
+plt.savefig('docs/eda/Correlation Matrix of Image Dimensions.png')
+plt.show()
+
+# Plot the distribution of image widths
+plt.figure(figsize=(10, 6))
+sns.histplot(image_dimensions_df['Width'], bins=20, kde=True)
+plt.title('Distribution of Image Widths')
+plt.xlabel('Width (Pixels)')
+plt.ylabel('Frequency')
+plt.savefig('docs/eda/Distribution of Image Widths.png')
+plt.show()
+
+# Plot the distribution of image heights
+plt.figure(figsize=(10, 6))
+sns.histplot(image_dimensions_df['Height'], bins=20, kde=True)
+plt.title('Distribution of Image Heights')
+plt.xlabel('Height (Pixels)')
+plt.ylabel('Frequency')
+plt.savefig('docs/eda/Distribution of Image Heights.png')
+plt.show()

eval.py

@@ -5,17 +5,23 @@ import pathlib
 from PIL import Image
 from torchmetrics import ConfusionMatrix, Accuracy, F1Score
 import matplotlib.pyplot as plt
+from sklearn.metrics import (
+    classification_report,
+    precision_recall_curve,
+    roc_curve,
+    auc,
+    confusion_matrix,
+)
 from configs import *
 from data_loader import load_data  # Import the load_data function
-
-image_path = "data/test/Task 1/"
+import numpy as np
 
 # Constants
 DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 
 # Load the model
 MODEL = MODEL.to(DEVICE)
-MODEL.load_state_dict(torch.load(MODEL_SAVE_PATH, map_location=DEVICE))
+MODEL.load_state_dict(torch.load(r"C:\Users\User\Documents\Flutter-test\handetect\assets\model.pt", map_location=DEVICE))
 MODEL.eval()
 
 
@@ -30,6 +36,7 @@ def predict_image(image_path, model, transform):
 
     true_classes = []
     predicted_labels = []
+    predicted_scores = []  # To store predicted class probabilities
 
     accuracy_metric = Accuracy(num_classes=NUM_CLASSES, task="multiclass")
     f1_metric = F1Score(num_classes=NUM_CLASSES, task="multiclass")
@@ -51,6 +58,9 @@ def predict_image(image_path, model, transform):
             # Append true and predicted labels to their respective lists
             true_classes.append(true_class)
             predicted_labels.append(predicted_class)
+            predicted_scores.append(
+                output.softmax(dim=1).cpu().numpy()
+            )  # Store predicted class probabilities
 
             # Check if the prediction is correct
             if predicted_class == true_class:
@@ -73,8 +83,18 @@ def predict_image(image_path, model, transform):
     # Plot the confusion matrix
     conf_matrix.compute()
     conf_matrix.plot()
+    plt.title("Confusion Matrix")
     plt.show()
 
+    # Classification report
+    class_names = [str(cls) for cls in range(NUM_CLASSES)]
+    report = classification_report(
+        true_classes, predicted_labels, target_names=class_names
+    )
+    print("Classification Report:\n", report)
+    
+    
+
 
-# Call predict_image function
-predict_image(image_path, MODEL, preprocess)
+# Call predict_image function with your image path
+predict_image("data/test/Task 1/", MODEL, preprocess)

test.py

@@ -0,0 +1,39 @@
+import torch
+import torch.optim as optim
+import torchvision.models as models
+import torchvision.transforms as transforms
+from configs import *
+
+# Load a pre-trained model (e.g., VGG16)
+MODEL = MODEL.to(DEVICE)
+MODEL.load_state_dict(torch.load(MODEL_SAVE_PATH, map_location=DEVICE))
+MODEL.eval()
+
+# Prepare an initial image (e.g., a random noise image)
+image = torch.randn(1, 3, 224, 224, requires_grad=True).cuda()
+
+# Define a loss function to maximize a specific layer or neuron's activation
+loss_function = torch.nn.CrossEntropyLoss()
+
+# Create an optimizer (e.g., Adam) for updating the image
+optimizer = optim.Adam([image], lr=0.01)
+
+# Optimization loop
+for _ in range(1000):
+    optimizer.zero_grad()
+    output = MODEL(image)
+    loss = -output[0, 'Healthy']  # Maximize the activation of a specific class
+    loss.backward()
+    optimizer.step()
+
+# Visualize the optimized image
+import matplotlib.pyplot as plt
+import torchvision.transforms as transforms
+
+# Convert the tensor to an image
+image = transforms.ToPILImage()(image.squeeze())
+
+# Display the generated image
+plt.imshow(image)
+plt.axis('off')
+plt.show()

tuning.py

@@ -12,7 +12,7 @@ from torch.utils.tensorboard import SummaryWriter
 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 EPOCHS = 10
 N_TRIALS = 1000
-TIMEOUT = 7200 
+TIMEOUT = 1800
 
 # Create a TensorBoard writer
 writer = SummaryWriter(log_dir="output/tensorboard/tuning")