Upload 10 files

AlzheimerModelCPU.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2241af42d3188aea27dcc36259f72e57a6ad06b555e1687c3f298e52c3128ce8
+size 134441434

AlzheimerTriMatterNet.py

@@ -0,0 +1,24 @@
+import torch.nn as nn
+import torchvision.models as models
+from Resnet18 import *
+    
+class AlzheimerTriMatterNet(nn.Module):
+    def __init__(self):
+        super(AlzheimerTriMatterNet, self).__init__()
+        self.numclass = 4
+        self.whitematter_resnet18_model = ResNet18(img_channels=3, num_layers=18, block=BasicBlock, num_classes=4)
+        self.graymatter_resnet18_model = ResNet18(img_channels=3, num_layers=18, block=BasicBlock, num_classes=4)
+        self.resnet18_model = ResNet18(img_channels=3, num_layers=18, block=BasicBlock, num_classes=4)
+        self.global_classification_head = nn.Sequential(
+                                                            nn.Linear(512*3,self.numclass),
+                                                            nn.Softmax(dim=1),
+        )
+        
+    def forward(self, whitematter, graymatter, original):
+        white_output = self.whitematter_resnet18_model(whitematter)
+        gray_output = self.graymatter_resnet18_model(graymatter)
+        origin_output = self.resnet18_model(original)
+        combined_tensor = torch.cat(( white_output, gray_output, origin_output), dim=1)
+        output = self.global_classification_head(combined_tensor)
+        return output
+    

Resnet18.py

@@ -0,0 +1,100 @@
+"""Code from : https://debuggercafe.com/implementing-resnet18-in-pytorch-from-scratch/"""
+import torch.nn as nn
+import torch
+from torchvision.ops import RoIPool
+from torch import Tensor
+from typing import Type
+
+class BasicBlock(nn.Module):
+    def __init__(self, in_channels: int,out_channels: int,stride: int = 1,expansion: int = 1,downsample: nn.Module = None) -> None:
+        super(BasicBlock, self).__init__()
+        # Multiplicative factor for the subsequent conv2d layer's output channels.
+        # It is 1 for ResNet18 and ResNet34.
+        self.expansion = expansion
+        self.downsample = downsample
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1,bias=False)
+        self.bn1 = nn.BatchNorm2d(out_channels)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv2d(out_channels, out_channels*self.expansion, kernel_size=3, padding=1,bias=False)
+        self.bn2 = nn.BatchNorm2d(out_channels*self.expansion)
+
+    def forward(self, x: Tensor) -> Tensor:
+        identity = x
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+        out = self.conv2(out)
+        out = self.bn2(out)
+        if self.downsample is not None:
+            identity = self.downsample(x)
+        out += identity
+        out = self.relu(out)
+        return  out
+
+class ResNet18(nn.Module):
+    def __init__(self, img_channels: int,num_layers: int,block: Type[BasicBlock],num_classes: int  = 1000) -> None:
+        super(ResNet18, self).__init__()
+        if num_layers == 18:
+            # The following `layers` list defines the number of `BasicBlock` 
+            # to use to build the network and how many basic blocks to stack
+            # together.
+            layers = [2, 2, 2, 2]
+            self.expansion = 1
+        
+        self.in_channels = 64
+        # All ResNets (18 to 152) contain a Conv2d => BN => ReLU for the first
+        # three layers. Here, kernel size is 7.
+        self.conv1 = nn.Conv2d(in_channels=img_channels,out_channels=self.in_channels,kernel_size=7, stride=2,padding=3,bias=False)
+        self.bn1 = nn.BatchNorm2d(self.in_channels)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(512*self.expansion, num_classes)
+
+    def _make_layer(self, block: Type[BasicBlock],out_channels: int,blocks: int,stride: int = 1) -> nn.Sequential:
+        downsample = None
+        if stride != 1:
+            """
+            This should pass from `layer2` to `layer4` or 
+            when building ResNets50 and above. Section 3.3 of the paper
+            Deep Residual Learning for Image Recognition
+            (https://arxiv.org/pdf/1512.03385v1.pdf).
+            """
+            downsample = nn.Sequential(
+                nn.Conv2d(self.in_channels, out_channels*self.expansion,kernel_size=1,stride=stride,bias=False),
+                nn.BatchNorm2d(out_channels * self.expansion),
+            )
+        layers = []
+        layers.append(
+            block(
+                self.in_channels, out_channels, stride, self.expansion, downsample
+            )
+        )
+        self.in_channels = out_channels * self.expansion
+        for i in range(1, blocks):
+            layers.append(block(
+                self.in_channels,
+                out_channels,
+                expansion=self.expansion
+            ))
+        return nn.Sequential(*layers)
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        # The spatial dimension of the final layer's feature 
+        # map should be (7, 7) for all ResNets.
+        #print('Dimensions of the last convolutional feature map: ', x.shape)
+        x = self.avgpool(x)
+        x = torch.flatten(x, 1)
+        #x = self.fc(x)
+        return x

app.py

@@ -0,0 +1,93 @@
+import gradio as gr
+import torch
+from utils import *
+import os
+
+model = torch.load('AlzheimerModelCPU.pth')
+model.eval()
+
+def reset():
+    return None, None, None, None, None
+
+with gr.Blocks() as demo:
+    gr.HTML("""
+        <h1 style="text-align: center; font-size: 50px;">
+            Alzheimer Detection
+        </h1>
+        <p style="text-align: center;">
+            Early Detection of Alzheimer's Disease: A Deep Learning Approach for Accurate Diagnosis.
+        </p>
+        <h3 style="text-align: left;">
+            To use the demo, please follow the steps below.
+        </h3>
+        <ul>
+            <li style="text-align: left; padding: 0px 0px 0px 30px;">
+                If you want to try examples, click one of <span style="font-weight: bold;">Examples</span> images below. Then, click 
+                <span style="font-weight: bold;">Submit</span>.
+            </li>
+            <li style="text-align: left; padding: 0px 0px 0px 30px;">
+                if you don't want to try examples, upload an image and click <span style="font-weight: bold;">Submit</span>.
+            </li>
+            <li style="text-align: left; padding: 0px 0px 0px 30px;">
+                You can adjust the <span style="font-weight: bold;">Target</span> for your desire visualization and 
+                <span style="font-weight: bold;">Plot Type</span> between <span style="font-weight: bold;">withmask</span> and <span style="font-weight: bold;">withoutmask</span>
+                to plot original images with or without Grad-CAM.
+            </li>
+            <li style="text-align: left; padding: 0px 0px 0px 30px;">
+                If you want to reset all components, click <span style="font-weight: bold;">Reset All Components</span> button.
+            </li>
+        </ul>
+        """
+    )
+    with gr.Row():
+
+        with gr.Column():
+            image_area = gr.Image(sources=["upload"], type="pil", scale=2, label="Upload Image")
+
+            with gr.Row():
+                choosen_plottype =gr.Radio(choices=["withmask", "withoutmask"], value="withmask", label="Plot Type", scale=1, interactive=True)
+                choosen_target = gr.Slider(minimum=0, maximum=200, step=1, value=100, label="Classifier OutputTarget", scale=1, interactive=True)
+                submit_btn = gr.Button("Submit", variant='primary', scale=1)
+                
+        with gr.Column():
+            gr.HTML("""
+            <h2 style="text-align: center;">
+                
+            </h2>
+            <h2 style="text-align: center;">
+                Output and Prediction
+            </h2>
+            <p style="text-align: center;">
+                Grad-CAM for 3 images. Original, White Matter, Gray Matter image.
+            </p>
+            """
+            )
+            text_area = gr.Textbox(label="Prediction Result")
+            plotarea_original = gr.Plot(label="Original image")
+            plotarea_white = gr.Plot(label="White Matter image")
+            plotarea_gray = gr.Plot(label="Gray Matter image")
+        
+            reset_btn = gr.Button("Reset All Components", variant='stop', scale=1) 
+
+    gr.HTML("""
+            <h2 style="text-align: left;">
+                Examples
+            </h2>
+            <p style="text-align: left;">
+                You can select 1 image from the examples and click "Submit".
+            </p>
+            """
+            )
+    examples = gr.Examples(examples=[   os.path.join(os.getcwd(), "examples\\non.jpg"), 
+                                        os.path.join(os.getcwd(),"examples\\verymild.jpg"), 
+                                        os.path.join(os.getcwd(), "examples\\mild.jpg"), 
+                                        os.path.join(os.getcwd(), "examples\\moderate.jpg")], 
+                                        inputs=image_area,
+                                        outputs=image_area, 
+                                        label="Examples",
+                                        )
+
+    submit_btn.click(lambda x, target, plot_type: predict_and_gradcam(x, model=model, target=target, plot_type=plot_type), inputs=[image_area, choosen_target, choosen_plottype], outputs=[text_area, plotarea_original, plotarea_white, plotarea_gray])
+    reset_btn.click(reset, outputs=[image_area, text_area, plotarea_original, plotarea_white, plotarea_gray])
+
+demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+torch
+torchvision
+matplotlib
+opencv-python
+numpy
+grad-cam

utils.py

@@ -0,0 +1,182 @@
+import torch
+from torchvision import transforms
+import matplotlib.pyplot as plt
+import cv2
+import numpy as np
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+
+class split_white_and_gray():
+    def __init__(self,threshold=120) -> None:
+        """
+        Initialize the class with a threshold value.
+
+        Args:
+            threshold (int, optional): The threshold value to be set. Defaults to 120.
+        """
+        self.threshold = threshold
+
+    def __call__(self,tensor):
+        """
+        Apply thresholding to the input tensor and return the white matter, gray matter, and the original tensor.
+        
+        Parameters:
+        tensor (torch.Tensor): The input tensor to be thresholded.
+        
+        Returns:
+        torch.Tensor: The thresholded white matter.
+        torch.Tensor: The thresholded gray matter.
+        torch.Tensor: The original input tensor.
+        """
+        tensor = (tensor*255).to(torch.int64)
+
+        # Apply thresholding
+        white_matter = torch.where(tensor >= self.threshold,tensor,0)
+        white_matter = (white_matter/255).to(torch.float64)
+        gray_matter = torch.where(tensor < self.threshold,tensor,0)
+        gray_matter = (gray_matter/255).to(torch.float64)
+        tensor = (tensor/255).to(torch.float64)
+
+        return white_matter, gray_matter,tensor
+    
+def showcam_withoutmask(original_image, grayscale_cam, image_title='Original Image'):
+    """This function applies the CAM mask to the original image and returns the Matplotlib Figure object.
+    
+    :param original_image: The original image tensor in PyTorch format.
+    :param grayscale_cam: The CAM mask tensor in PyTorch format.
+
+    :return: Matplotlib Figure object.
+    """
+    # Assuming you have two tensors: 'original_image' and 'cam_mask'
+    # Make sure both tensors are on the CPU
+    original_image = torch.squeeze(original_image).cpu()  # torch.Size([3, 150, 150])
+    cam_mask = grayscale_cam.cpu()  # torch.Size([1, 150, 150])
+
+    # Convert the tensors to NumPy arrays
+    original_image_np = original_image.numpy()
+    cam_mask_np = cam_mask.numpy()
+
+    # Apply the mask to the original image
+    masked_image = original_image_np * cam_mask_np
+
+    # Normalize the masked_image
+    masked_image_norm = (masked_image - np.min(masked_image)) / (np.max(masked_image) - np.min(masked_image))
+
+    # Create Matplotlib Figure
+    fig, axes = plt.subplots(1, 3, figsize=(18, 5))
+
+    # Plot the original image
+    axes[0].imshow(original_image_np.transpose(1, 2, 0))  # Assuming your original image is in (C, H, W) format
+    axes[0].set_title(image_title)
+
+    # Plot the CAM mask
+    axes[1].imshow(cam_mask_np[0], cmap='jet')  # Assuming your mask is grayscale
+    axes[1].set_title('CAM Mask')
+
+    # Plot the overlay (normalized)
+    axes[2].imshow(masked_image_norm.transpose(1, 2, 0))  # Assuming your original image is in (C, H, W) format
+    axes[2].set_title('Overlay (Normalized)')
+
+    return fig
+
+def showcam_withmask(img_tensor: torch.Tensor,
+                     mask_tensor: torch.Tensor,
+                     use_rgb: bool = False,
+                     colormap: int = cv2.COLORMAP_JET,
+                     image_weight: float = 0.5,
+                     image_title: str = 'Original Image') -> plt.Figure:
+    """ This function overlays the CAM mask on the image as a heatmap and returns the Figure object.
+    By default, the heatmap is in BGR format.
+
+    :param img_tensor: The base image tensor in PyTorch format.
+    :param mask_tensor: The CAM mask tensor in PyTorch format.
+    :param use_rgb: Whether to use an RGB or BGR heatmap; set to True if 'img_tensor' is in RGB format.
+    :param colormap: The OpenCV colormap to be used.
+    :param image_weight: The final result is image_weight * img + (1-image_weight) * mask.
+
+    :return: Matplotlib Figure object.
+    """
+    # Convert PyTorch tensors to NumPy arrays
+    img = img_tensor.cpu().numpy().transpose(1, 2, 0)
+    mask = mask_tensor.cpu().numpy()
+
+    # Convert the mask to a single-channel image
+    mask_single_channel = np.uint8(255 * mask[0])
+
+    heatmap = cv2.applyColorMap(mask_single_channel, colormap)
+
+    if use_rgb:
+        heatmap = cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB)
+
+    heatmap = np.float32(heatmap) / 255
+
+    if np.max(img) > 1:
+        raise Exception("The input image should be in the range [0, 1]")
+
+    if image_weight < 0 or image_weight > 1:
+        raise Exception(f"image_weight should be in the range [0, 1]. Got: {image_weight}")
+
+    cam = (1 - image_weight) * heatmap + image_weight * img
+    cam = cam / np.max(cam)
+
+    # Create Matplotlib Figure
+    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
+
+    # Plot the original image
+    axes[0].imshow(img)
+    axes[0].set_title(image_title)
+
+    # Plot the CAM mask
+    axes[1].imshow(mask[0], cmap='jet')
+    axes[1].set_title('CAM Mask')
+
+    # Plot the overlay
+    axes[2].imshow(cam)
+    axes[2].set_title('Overlay')
+
+    return fig
+
+def predict_and_gradcam(pil_image, model, target=100, plot_type='withmask'):
+    transform = transforms.Compose([
+        transforms.Resize((150, 150)),
+        transforms.Grayscale(num_output_channels=3),
+        transforms.ToTensor(),
+        split_white_and_gray(120),
+    ])
+    white_matter_tensor, gray_matter_tensor, origin_tensor = transform(pil_image)
+    white_matter_tensor, gray_matter_tensor, origin_tensor = white_matter_tensor.unsqueeze(0).to(torch.float32),\
+        gray_matter_tensor.unsqueeze(0).to(torch.float32),\
+        origin_tensor.unsqueeze(0).to(torch.float32)
+    
+    def calculate_gradcammask(model_grad, input_tensor):
+        target_layer = [model_grad.layer4[-1]] 
+        gradcam = GradCAM(model=model_grad, target_layers=target_layer)
+        targets = [ClassifierOutputTarget(target)]
+        grayscale_cam = gradcam(input_tensor=input_tensor, targets=targets, aug_smooth=True, eigen_smooth=True)
+        grayscale_cam = torch.tensor(grayscale_cam)
+
+        return grayscale_cam
+    
+    origin_model = model.resnet18_model
+    white_model = model.whitematter_resnet18_model
+    gray_model = model.graymatter_resnet18_model
+
+    origin_cam = calculate_gradcammask(origin_model, origin_tensor)
+    white_cam = calculate_gradcammask(white_model, white_matter_tensor)
+    gray_cam = calculate_gradcammask(gray_model, gray_matter_tensor)
+
+    class_idx = {0: 'Moderate Demented', 1: 'Mild Demented', 2: 'Very Mild Demented', 3: 'Non Demented'}
+    prediction = model(white_matter_tensor, gray_matter_tensor, origin_tensor)
+    predicted_class_index = torch.argmax(prediction).item()
+    predicted_class_label = class_idx[predicted_class_index]
+
+    if plot_type == 'withmask':
+        return  predicted_class_label, showcam_withmask(torch.squeeze(origin_tensor), origin_cam),\
+                showcam_withmask(torch.squeeze(white_matter_tensor), white_cam, image_title='White Matter'),\
+                showcam_withmask(torch.squeeze(gray_matter_tensor), gray_cam, image_title='Gray Matter')
+    elif plot_type == 'withoutmask':
+        return  predicted_class_label, showcam_withoutmask(torch.squeeze(origin_tensor),origin_cam),\
+                showcam_withoutmask(torch.squeeze(white_matter_tensor),white_cam, image_title='White Matter'),\
+                showcam_withoutmask(torch.squeeze(gray_matter_tensor),gray_cam , image_title='Gray Matter')
+    else:
+        raise ValueError("plot_type must be either 'withmask' or 'withoutmask'")