Update

app.py

@@ -1,63 +1,150 @@
 import gradio as gr
 import predict as predict
 import extract as extract
+import lime_eval as lime_eval
+
 
 def upload_file(files):
     file_paths = [file.name for file in files]
     return file_paths
 
 
-def process_file(webcam_filepath, upload_filepath, ):
+def process_file(
+    upload_filepath,
+    gradcam_toggle,
+    lime_toggle,
+):
+    print("Upload filepath:", upload_filepath)
+    print("GradCAM toggle:", gradcam_toggle)
+    print("LIME toggle:", lime_toggle)
     result = []
-    if webcam_filepath == None:
-        sorted_classes = predict.predict_image(upload_filepath)
-        for class_label, class_prob in sorted_classes:
-            class_prob = class_prob.item().__round__(2)
-            result.append(f"{class_label}: {class_prob}%")
+    sorted_classes = predict.predict_image(upload_filepath)
+    for class_label, class_prob in sorted_classes:
+        class_prob = class_prob.item().__round__(2)
+        result.append(f"{class_label}: {class_prob}%")
+    result = result[:4]
+    if gradcam_toggle == True:
         cam = extract.extract_gradcam(upload_filepath, save_path="gradcam.jpg")
-        result = result[:3]
-        result.append("gradcam.jpg")
-        return result
-    elif upload_filepath == None:
-        sorted_classes = predict.predict_image(webcam_filepath)
-        for class_label, class_prob in sorted_classes:
-            class_prob = class_prob.item().__round__(2)
-            result.append(f"{class_label}: {class_prob}%")
-        cam = extract.extract_gradcam(webcam_filepath, save_path="gradcam.jpg")
-        result = result[:3]
         result.append("gradcam.jpg")
-        return result
     else:
-        sorted_classes = predict.predict_image(upload_filepath)
-        for class_label, class_prob in sorted_classes:
-            class_prob = class_prob.item().__round__(2)
-            result.append(f"{class_label}: {class_prob}%")
-        cam = extract.extract_gradcam(upload_filepath, save_path="gradcam.jpg")
-        # Only keep the first 3 results
-        result = result[:3]
-        result.append("gradcam.jpg")
-        return result
-
-
-
-demo = gr.Interface(
-    theme="gradio/soft",
-    fn=process_file,
-    title="HANDETECT",
-    
-    inputs=[
-        gr.components.Image(type="filepath", label="Choose Image", source="upload"),
-    ],
-    outputs=[
-        gr.outputs.Textbox(label="Probability 1"),
-        gr.outputs.Textbox(label="Probability 2"),
-        gr.outputs.Textbox(label="Probability 3"),
-        # GradCAM
-        gr.outputs.Image(label="GradCAM++", type="filepath"),
-        
-        
-    ],
-    
-)
+        result.append(None)
+    if lime_toggle == True:
+        lime = lime_eval.generate_lime(upload_filepath, save_path="lime.jpg")
+        result.append("lime.jpg")
+    else:
+        result.append(None)
+    return result
+    # else:
+    #     sorted_classes = predict.predict_image(upload_filepath)
+    #     for class_label, class_prob in sorted_classes:
+    #         class_prob = class_prob.item().__round__(2)
+    #         result.append(f"{class_label}: {class_prob}%")
+    #     result = result[:4]
+    #     if gradcam_toggle == 1:
+    #         cam = extract.extract_gradcam(upload_filepath, save_path="gradcam.jpg")
+    #         result.append("gradcam.jpg")
+    #     if lime_toggle == 1:
+    #         lime = lime_eval.generate_lime(upload_filepath, save_path="lime.jpg")
+    #         result.append("lime.jpg")
+    #     return result
+
+
+# Prerun to innitialize the model
+# process_file(None, r"data\test\Task 1\Dystonia\0c08d2ea-8e1c-4ac6-92db-a752388b30cf.png")
+
+css = """
+.block {
+    margin-left: auto;
+    margin-right: auto;
+    width: 100%;
+}
+#image_input {
+    width: 200% !important;
+}
+#image_input img {
+    width: 200% !important;
+}
+.output-image {
+    width: 70% !important;
+        text-align: -webkit-center !important;
+}
+.output-image img {
+    width:  300px !important;
+}
+.toggle {
+    width: 17% !important;
+}
+.show-api {
+    visibility: hidden !important;
+}
+
+.built-with {
+    visibility: hidden !important;
+}
+"""
+
+block = gr.Blocks(title="HANDETECT", css=css, theme="gradio/soft")
+
+block.queue()
+block.title = "HANDETECT"
+
+with block as demo:
+    with gr.Column():
+        with gr.Row():
+            image_input = gr.Image(
+                type="filepath",
+                label="Choose Image",
+                source="upload",
+                elem_id="image_input",
+            )
+            with gr.Column():
+                gradcam_toggle = gr.Checkbox(
+                    label="GradCAM", default=False
+                )
+                lime_toggle = gr.Checkbox(
+                    label="LIME", default=False
+                )
+        with gr.Row():
+            submit_button = gr.Button(value="Submit")
+            # cancel_button = gr.Button(value="Cancel")
+        # theme="gradio/soft",
+        # fn=process_file,
+        # title="HANDETECT",
+        # outputs=[
+        with gr.Row():
+            prob1_textbox = gr.outputs.Textbox(label="Probability 1")
+            prob2_textbox = gr.outputs.Textbox(label="Probability 2")
+            prob3_textbox = gr.outputs.Textbox(label="Probability 3")
+            prob4_textbox = gr.outputs.Textbox(label="Probability 4")
+            # GradCAM
+        with gr.Row():
+            gradcam_output = gr.Image(
+                label="Feature Explanation",
+                type="filepath",
+                elem_classes=["output-image"],
+            )
+            lime_output = gr.Image(
+                label="Feature Explanation",
+                type="filepath",
+                elem_classes=["output-image"],
+            )
+
+        submit_button.click(
+            process_file,
+            [image_input, gradcam_toggle, lime_toggle],
+            [
+                prob1_textbox,
+                prob2_textbox,
+                prob3_textbox,
+                prob4_textbox,
+                gradcam_output,
+                lime_output,
+            ],
+            show_progress="minimal",
+            preprocess=upload_file,
+            scroll_to_output=True,
+            # cancels=[cancel_button],
+        )
+
 
 demo.launch()

calculate.py

@@ -1,18 +0,0 @@
-from scipy.optimize import linprog
-
-# Coefficients for the objective function (negative because linprog does minimization)
-c = [-0.88, -0.88, -0.85]
-
-# Coefficients for the inequality constraint (sum of weights = 1)
-A = [[1, 1, 1]]
-b = [1]
-
-# Bounds for each weight (between 0 and 1)
-bounds = [(0, 1), (0, 1), (0, 1)]
-
-# Solve the linear programming problem
-result = linprog(c, A_eq=A, b_eq=b, bounds=bounds)
-
-# The optimal weights
-optimal_weights = result.x
-print("Optimal weights:", optimal_weights)

eda.py

@@ -5,10 +5,10 @@ import matplotlib.pyplot as plt
 import seaborn as sns
 from matplotlib import rcParams
 
-rcParams['font.family'] = 'Times New Roman'
+rcParams["font.family"] = "Times New Roman"
 
 # Define the directory where your dataset is located
-dataset_directory = 'data/train/combined/Task 1/'
+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)
@@ -18,7 +18,7 @@ num_samples_per_class = []
 class_labels_processed = []
 
 # Initialize an empty DataFrame to store image dimensions
-image_dimensions_df = pd.DataFrame(columns=['Height', 'Width'])
+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}
@@ -30,74 +30,81 @@ for label in class_labels:
         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)
-            
+            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})
+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')
+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.xlabel("Class Label")
+plt.ylabel("Number of Samples")
+plt.subplots_adjust(
+    top=0.88, bottom=0.21, left=0.125, right=0.9, hspace=0.2, wspace=0.2
+)
+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.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}')
+    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.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')
+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')
+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')
+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_orig.py

@@ -13,10 +13,12 @@ from sklearn.metrics import (
     accuracy_score,
     f1_score,
     confusion_matrix,
+    matthews_corrcoef,
     ConfusionMatrixDisplay,
     roc_curve,
     auc,
     average_precision_score,
+    cohen_kappa_score,
 )
 from sklearn.preprocessing import label_binarize
 from configs import *
@@ -27,7 +29,7 @@ from data_loader import load_data  # Import the load_data function
 # SquuezeNet: 0.8865856365856365
 
 
-rcParams['font.family'] = 'Times New Roman'
+rcParams["font.family"] = "Times New Roman"
 
 # Load the model
 model = MODEL.to(DEVICE)
@@ -103,18 +105,32 @@ def predict_image(image_path, model, transform):
     true_classes_tensor = torch.tensor(true_classes)
 
     # Calculate the confusion matrix
-    conf_matrix = confusion_matrix(true_classes, predicted_labels)
+    conf_matrix = confusion_matrix(
+        true_classes,
+        predicted_labels,
+    )
 
     # Plot the confusion matrix
-    ConfusionMatrixDisplay(
-        confusion_matrix=conf_matrix, display_labels=range(NUM_CLASSES)
-    ).plot(cmap=plt.cm.Blues)
+    ConfusionMatrixDisplay(confusion_matrix=conf_matrix, display_labels=CLASSES).plot(
+        cmap=plt.cm.Blues, xticks_rotation=25
+    )
+    # Use the exported value of margin_left to adjust the space between the yticklabels and the yticks
+    plt.subplots_adjust(
+        top=0.935,
+        bottom=0.155,
+        left=0.125,
+        right=0.905,
+        hspace=0.2,
+        wspace=0.2,
+    )
     plt.title("Confusion Matrix")
+    manager = plt.get_current_fig_manager()
+    manager.full_screen_toggle()
     plt.savefig("docs/efficientnet/confusion_matrix.png")
     plt.show()
 
     # Classification report
-    class_names = [str(cls) for cls in range(NUM_CLASSES)]
+    class_names = CLASSES
     report = classification_report(
         true_classes, predicted_labels, target_names=class_names
     )
@@ -156,7 +172,7 @@ def predict_image(image_path, model, transform):
     )
     plt.savefig("docs/efficientnet/prc.png")
     plt.show()
-    
+
     # Plot ROC curve
     plt.figure(figsize=(10, 6))
     plt.plot(fpr, tpr)
@@ -172,6 +188,13 @@ def predict_image(image_path, model, transform):
     )
     plt.savefig("docs/efficientnet/roc.png")
     plt.show()
+    
+    
+    # Matthew's correlation coefficient
+    print("Matthew's correlation coefficient:", matthews_corrcoef(true_classes, predicted_labels))
+    
+    # Cohen's kappa
+    print("Cohen's kappa:", cohen_kappa_score(true_classes, predicted_labels))
 
 
 predict_image("data/test/Task 1/", model, preprocess)

extract.py

@@ -21,37 +21,43 @@ for child in model.features[-1]:
 if target_layer is None:
     raise ValueError("Invalid layer name: {}".format(target_layer))
 
+
+
 def extract_gradcam(image_path=None, save_path=None):
     if image_path is None:
         for disease in CLASSES:
             print("Processing", disease)
-            image_path = random.choice(os.listdir("data/test/Task 1/" + disease))
-            image_path = "data/test/Task 1/" + disease + "/" + image_path
-            rgb_img = cv2.imread(image_path, 1)
-            rgb_img = np.float32(rgb_img) / 255
-            input_tensor = preprocess_image(rgb_img, mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
-            input_tensor = input_tensor.to(DEVICE)
+            for image_path in os.listdir(r'data\test\Task 1\{}'.format(disease)):
+                print("Processing", image_path)
+                image_path = r'data\test\Task 1\{}\{}'.format(disease, image_path)
+                image_name = image_path.split('.')[0].split('\\')[-1]
+                print("Processing", image_name)
+                rgb_img = cv2.imread(image_path, 1)
+                rgb_img = np.float32(rgb_img) / 255
+                input_tensor = preprocess_image(rgb_img, mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+                input_tensor = input_tensor.to(DEVICE)
 
-            # Create a GradCAMPlusPlus object
-            cam = GradCAMPlusPlus(model=model, target_layers=[target_layer], use_cuda=True)
+                # Create a GradCAMPlusPlus object
+                cam = GradCAMPlusPlus(model=model, target_layers=[target_layer], use_cuda=True)
 
-            # Generate the GradCAM heatmap
-            grayscale_cam = cam(input_tensor=input_tensor)[0]
+                # Generate the GradCAM heatmap
+                grayscale_cam = cam(input_tensor=input_tensor)[0]
 
-            # Apply a colormap to the grayscale heatmap
-            heatmap_colored = cv2.applyColorMap(np.uint8(255 * grayscale_cam), cv2.COLORMAP_JET)
+                # Apply a colormap to the grayscale heatmap
+                heatmap_colored = cv2.applyColorMap(np.uint8(255 * grayscale_cam), cv2.COLORMAP_JET)
 
-            # Ensure heatmap_colored has the same dtype as rgb_img
-            heatmap_colored = heatmap_colored.astype(np.float32) / 255
+                # Ensure heatmap_colored has the same dtype as rgb_img
+                heatmap_colored = heatmap_colored.astype(np.float32) / 255
 
-            # Adjust the alpha value to control transparency
-            alpha = 0.3  # You can change this value to make the original image more or less transparent
+                # Adjust the alpha value to control transparency
+                alpha = 0.3  # You can change this value to make the original image more or less transparent
 
-            # Overlay the colored heatmap on the original image
-            final_output = cv2.addWeighted(rgb_img, 0.3, heatmap_colored, 0.7, 0)
+                # Overlay the colored heatmap on the original image
+                final_output = cv2.addWeighted(rgb_img, 0.3, heatmap_colored, 0.7, 0)
 
-            # Save the final output
-            cv2.imwrite(f'docs/efficientnet/gradcam/{disease}.jpg', (final_output * 255).astype(np.uint8))
+                # Save the final output
+                os.makedirs(f'docs/efficientnet/gradcam/{disease}', exist_ok=True)
+                cv2.imwrite(f'docs/efficientnet/gradcam/{disease}/{image_name}.jpg', (final_output * 255).astype(np.uint8))
     else:
             rgb_img = cv2.imread(image_path, 1)
             rgb_img = np.float32(rgb_img) / 255

lime_eval.py

@@ -0,0 +1,108 @@
+import numpy as np
+from lime.lime_image import LimeImageExplainer
+from PIL import Image
+import torch
+import torchvision.transforms as transforms
+import matplotlib.pyplot as plt
+from matplotlib.colors import Normalize
+from configs import *
+from sklearn.preprocessing import minmax_scale
+
+
+model = MODEL.to(DEVICE)
+model.load_state_dict(torch.load(MODEL_SAVE_PATH))
+model.eval()
+
+
+# Define a function to predict with the model
+def predict(input_image):
+    input_image = torch.tensor(input_image, dtype=torch.float32)
+    if input_image.dim() == 4:
+        input_image = input_image.permute(0, 3, 1, 2)  # Permute the dimensions
+    input_image = input_image.to(DEVICE)  # Move to the appropriate device
+    with torch.no_grad():
+        output = model(input_image)
+    return output
+
+
+def generate_lime(image_path=None, save_path=None):
+    if image_path is None:
+        for disease in CLASSES:
+            print("Processing", disease)
+            for image_path in os.listdir(r"data\test\Task 1\{}".format(disease)):
+                image = None
+                print("Processing", image_path)
+                image_path = r"data\test\Task 1\{}\{}".format(disease, image_path)
+                image_name = image_path.split(".")[0].split("\\")[-1]
+                print("Processing", image_name)
+                image = Image.open(image_path).convert("RGB")
+                image = preprocess(image)
+                image = image.unsqueeze(0)  # Add batch dimension
+                image = image.to(DEVICE)
+
+                # Create the LIME explainer
+                explainer = LimeImageExplainer()
+
+                # Explain the model's predictions for the image
+                explanation = explainer.explain_instance(
+                    image[0].permute(1, 2, 0).numpy(),
+                    predict,
+                    top_labels=5,
+                    num_samples=1000,
+                )
+
+                # Get the image and mask for the explanation
+                image, mask = explanation.get_image_and_mask(
+                    explanation.top_labels[0],
+                    positive_only=False,
+                    num_features=10,
+                    hide_rest=False,
+                )
+
+                # Save the image (dun use plt.imsave)
+                # Normalize the image to the [0, 1] range
+                # norm = Normalize(vmin=0, vmax=1)
+                # image = norm(image)
+
+                image = (image - np.min(image)) / (np.max(image) - np.min(image))
+
+                # image = Image.fromarray(image)
+                os.makedirs(f"docs/efficientnet/lime/{disease}", exist_ok=True)
+                # image.save(f'docs/efficientnet/lime/{disease}/{image_name}.jpg')
+                plt.imsave(f"docs/efficientnet/lime/{disease}/{image_name}.jpg", image)
+
+    else:
+        image = None
+        print("Processing", image_path)
+        image = Image.open(image_path).convert("RGB")
+        image = preprocess(image)
+        image = image.unsqueeze(0)  # Add batch dimension
+        image = image.to(DEVICE)
+
+        # Create the LIME explainer
+        explainer = LimeImageExplainer()
+
+        # Explain the model's predictions for the image
+        explanation = explainer.explain_instance(
+            image[0].permute(1, 2, 0).numpy(), predict, top_labels=5, num_samples=1000
+        )
+
+        # Get the image and mask for the explanation
+        image, mask = explanation.get_image_and_mask(
+            explanation.top_labels[0],
+            positive_only=False,
+            num_features=10,
+            hide_rest=False,
+        )
+
+        # Save the image (dun use plt.imsave)
+        # Normalize the image to the [0, 1] range
+        # norm = Normalize(vmin=0, vmax=1)
+        # image = norm(image)
+
+        image = (image - np.min(image)) / (np.max(image) - np.min(image))
+
+        # image = Image.fromarray(image)
+        # os.makedirs(f"docs/efficientnet/lime/{disease}", exist_ok=True)
+        # image.save(f'docs/efficientnet/lime/{disease}/{image_name}.jpg')
+        plt.imsave(save_path, image)

lrp-eval.py

@@ -0,0 +1,16 @@
+import torch
+from torchvision.models import vgg16, VGG16_Weights
+from src.lrp import LRPModel
+from configs import *
+from PIL import Image
+
+
+image = Image.open(r'data\test\Task 1\Alzheimer Disease\0d846ee1-c90d-4ed5-8467-3550dd653858.png').convert("RGB")
+image = preprocess(image).unsqueeze(0)
+image = image.to(DEVICE)
+model = MODEL.to(DEVICE)
+print(dict(model.named_modules()))
+model.load_state_dict(torch.load(MODEL_SAVE_PATH, map_location=DEVICE))
+model.eval()
+lrp_model = LRPModel(model)
+r = lrp_model.forward(image)

plot-gradcam.py

@@ -1,30 +1,65 @@
-# Plot the gradcam pics of 7 classes from C:\Users\User\Documents\PISTEK\HANDETECT\docs\efficientnet\gradcam folder
-# Each picture is named as <class_name>.jpg
-# Usage: python plot-gradcam.py
+# Plot a table, each column is a test image, separate to 7 tables (one for each disease), each column have 4 rows, one is disease name, one is gradcam, one is lime, one is original image
 
 import os
 import cv2
 import numpy as np
+import torch
+import torchvision.transforms as transforms
 import matplotlib.pyplot as plt
-from matplotlib import rcParams
+from matplotlib.colors import Normalize
+from configs import *
+from sklearn.preprocessing import minmax_scale
 
-rcParams['font.family'] = 'Times New Roman'
+plt.rcParams["font.family"] = "Times New Roman"
+
+# Plot a table, each column is a test image, separate to 7 plot (one for each disease), each column have 4 rows, one is disease name, one is gradcam, one is lime, one is original image, the images are in 'docs/efficientnet/gradcam' and 'docs/efficientnet/lime' and 'data/test/Task 1'
 
-# Load the gradcam pics
-gradcam_dir = r'C:\Users\User\Documents\PISTEK\HANDETECT\docs\efficientnet\gradcam'
-gradcam_pics = []
-for pic in os.listdir(gradcam_dir):
-    gradcam_pics.append(cv2.imread(os.path.join(gradcam_dir, pic), 1))
-    
-# Plot the gradcam pics
-plt.figure(figsize=(20, 20))
-# Very tight layout
-plt.tight_layout(pad=0.1)
-for i, pic in enumerate(gradcam_pics):
-    plt.subplot(3, 3, i + 1)
-    plt.imshow(pic)
-    plt.axis('off')
-    plt.title(os.listdir(gradcam_dir)[i].split('.')[0], fontsize=13)
-plt.savefig('docs/efficientnet/gradcam.jpg')
-plt.show()
 
+def plot_table():
+    diseases = CLASSES
+    diseases.sort()
+    # diseases = ["Atelectasis", "Cardiomegaly", "Consolidation", "Edema", "Effusion", "Emphysema", "Fibrosis", "Hernia", "Infiltration", "Mass", "Nodule", "Pleural_Thickening", "Pneumonia", "Pneumothorax"]
+    print(diseases)
+    fig, axs = plt.subplots(4, 14, figsize=(20, 10))
+    fig.tight_layout()
+    for i, disease in enumerate(diseases):
+        # Create a new plot
+        print("Processing", disease)
+        axs[0, i].axis("off")
+        axs[0, i].set_title(disease)
+        axs[1, i].axis("off")
+        axs[1, i].set_title("GradCAM")
+        axs[2, i].axis("off")
+        axs[2, i].set_title("LIME")
+        axs[3, i].axis("off")
+        axs[3, i].set_title("Original")
+        # For each image in test folder, there are corresponding ones in gradcam folder and lime folder, plot it accordingly
+        for j, image_path in enumerate(os.listdir(r"data\test\Task 1\{}".format(disease))):
+            print("Processing", image_path)
+            image_path = r"data\test\Task 1\{}\{}".format(disease, image_path)
+            image_name = image_path.split(".")[0].split("\\")[-1]
+            print("Processing", image_name)
+            # Plot the original image
+            image = cv2.imread(image_path, 1)
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            axs[3, i].imshow(image)
+            # Plot the gradcam image
+            image = cv2.imread(
+                f"docs/efficientnet/gradcam/{disease}/{image_name}.jpg", 1
+            )
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            axs[1, i].imshow(image)
+            # Plot the lime image
+            image = cv2.imread(
+                f"docs/efficientnet/lime/{disease}/{image_name}.jpg", 1
+            )
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            axs[2, i].imshow(image)
+            # # Plot the disease name
+            # axs[0, i].text(0.5, 0.5, disease, horizontalalignment="center")
+        plt.savefig("docs/efficientnet/table.png")
+        plt.show()
+    
+if __name__ == "__main__":
+    plot_table()
+    

shap_eval.py

@@ -1,49 +1,37 @@
-import numpy as np
-from lime.lime_image import LimeImageExplainer
-from PIL import Image
+# Import necessary libraries
+import shap
 import torch
-import torchvision.transforms as transforms
-import matplotlib.pyplot as plt
+import numpy as np
+
+# Load your EfficientNetB3 model
+from torchvision import models
+
+# Load your test data
+from data_loader import load_test_data  # Replace with your actual data loader function
 from configs import *
 
+# Define your EfficientNetB3 model and load its pre-trained weights
+model = MODEL
 
-model = MODEL.to(DEVICE)
-model.load_state_dict(torch.load(MODEL_SAVE_PATH))
+# Set your model to evaluation mode
 model.eval()
 
-# Load the image
-image = Image.open(
-    r"data\test\Task 1\Healthy\0a7259b2-e650-43aa-93a0-e8b1063476fc.png"
-).convert("RGB")
-image = preprocess(image)
-image = image.unsqueeze(0)  # Add batch dimension
-image = image.to(DEVICE)
-
-
-# Define a function to predict with the model
-def predict(input_image):
-    input_image = torch.tensor(input_image, dtype=torch.float32)
-    if input_image.dim() == 4:
-        input_image = input_image.permute(0, 3, 1, 2)  # Permute the dimensions
-    input_image = input_image.to(DEVICE)  # Move to the appropriate device
-    with torch.no_grad():
-        output = model(input_image)
-    return output
-
-
-# Create the LIME explainer
-explainer = LimeImageExplainer()
-
-# Explain the model's predictions for the image
-explanation = explainer.explain_instance(
-    image[0].permute(1, 2, 0).numpy(), predict, top_labels=5, num_samples=2000
-)
-
-# Get the image and mask for the explanation
-image, mask = explanation.get_image_and_mask(
-    explanation.top_labels[0], positive_only=False, num_features=5, hide_rest=False
-)
-
-# Display the explanation
-plt.imshow(image)
-plt.show()
+# Load your test data using your data loader
+test_loader = load_test_data(TEST_DATA_DIR + "1", preprocess)  # Replace with your test data loader
+
+# Choose a specific image from the test dataset
+image, _ = next(iter(test_loader))
+
+# Make sure your model and input data are on the same device (CPU or GPU)
+device = DEVICE
+model = model.to(device)
+image = image.to(device)
+
+# Initialize an explainer for your model using SHAP's DeepExplainer
+explainer = shap.DeepExplainer(model, data=test_loader)
+
+# Calculate SHAP values for your chosen image
+shap_values = explainer(image)
+
+# Summarize the feature importance for the specific image
+shap.summary_plot(shap_values, image)

test-speed.py

@@ -0,0 +1,93 @@
+from gradio_client import Client
+import time
+import csv
+import matplotlib.pyplot as plt
+from matplotlib import rcParams
+from configs import *
+from PIL import Image
+
+client = Client("https://cycool29-handetect.hf.space/")
+
+list_of_times = []
+
+
+rcParams["font.family"] = "Times New Roman"
+
+# Load the model
+model = MODEL.to(DEVICE)
+model.load_state_dict(torch.load(MODEL_SAVE_PATH, map_location=DEVICE))
+model.eval()
+
+for disease in CLASSES:
+    print("Processing", disease)
+    for image_path in os.listdir(r"data\test\Task 1\{}".format(disease)):
+        # print("Processing", image_path)
+        image_path = r"data\test\Task 1\{}\{}".format(disease, image_path)
+        start_time = time.time()
+        result = client.predict(
+                        image_path,	
+                        api_name="/predict"
+        )
+        time_taken = time.time() - start_time
+        list_of_times.append(time_taken)
+        print("Time taken:", time_taken)
+
+        # Log to csv
+        with open('log.csv', 'a', newline='') as file:
+            writer = csv.writer(file)
+            writer.writerow([disease])
+            writer.writerow([image_path])
+            writer.writerow([time_taken])
+            
+
+print("Average time taken:", sum(list_of_times)/len(list_of_times))
+print("Max time taken:", max(list_of_times))
+print("Min time taken:", min(list_of_times))
+print("Total time taken:", sum(list_of_times))
+print("Median time taken:", sorted(list_of_times)[len(list_of_times)//2])
+
+# Plot the histogram
+plt.hist(list_of_times, bins=10)
+plt.xlabel("Time taken (s)")
+plt.ylabel("Frequency")
+plt.title("Time taken to process each image")
+plt.savefig("docs/efficientnet/time_taken_for_web.png")
+
+
+# Now is local
+list_of_times = []
+
+for disease in CLASSES:
+    print("Processing", disease)
+    for image_path in os.listdir(r"data\test\Task 1\{}".format(disease)):
+        # print("Processing", image_path)
+        image_path = r"data\test\Task 1\{}\{}".format(disease, image_path)
+        start_time = time.time()
+        image = Image.open(image_path).convert("RGB")
+        image = preprocess(image).unsqueeze(0)
+        image = image.to(DEVICE)
+        output = model(image)
+        time_taken = time.time() - start_time
+        list_of_times.append(time_taken)
+        print("Time taken:", time_taken)
+
+        # Log to csv
+        with open('log.csv', 'a', newline='') as file:
+            writer = csv.writer(file)
+            writer.writerow([disease])
+            writer.writerow([image_path])
+            writer.writerow([time_taken])
+
+
+print("Average time taken local:", sum(list_of_times)/len(list_of_times))
+print("Max time taken local:", max(list_of_times))
+print("Min time taken local:", min(list_of_times))
+print("Total time taken local:", sum(list_of_times))
+print("Median time taken local:", sorted(list_of_times)[len(list_of_times)//2])
+
+# Plot the histogram
+plt.hist(list_of_times, bins=10)
+plt.xlabel("Time taken (s) local")
+plt.ylabel("Frequency local")
+plt.title("Time taken to process each image local")
+plt.savefig("docs/efficientnet/time_taken_for_local.png")

testing.py

@@ -1,5 +0,0 @@
-import torch
-
-print("Torch version:",torch.__version__)
-
-print("Is CUDA enabled?",torch.cuda.is_available())