X-RAY BASE

Utils/CT_Scan_Utils.py

@@ -0,0 +1,122 @@
+import cv2
+from PIL import Image
+import torch
+import matplotlib.pyplot as plt
+import torch.functional as F
+import torch.nn as nn
+import numpy as np
+import torchvision.transforms as transform
+# !pip install efficientnet_pytorch -q
+from efficientnet_pytorch import EfficientNet
+
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+else:
+    device = torch.device("cpu")
+
+val_transform = transform.Compose([transform.Resize(size=(224, 224)),
+                                   transform.ToTensor(),
+                                   transform.Normalize(mean=[0.485, 0.456, 0.406],
+                                                        std=[0.229, 0.224, 0.225])
+                                                        ])
+
+def transform_image(image, transforms):
+    # img = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB)
+    img = transforms(image)
+    img = img.unsqueeze(0)
+    return img
+
+class Efficient(nn.Module):
+    def __init__(self, num_classes:int=1):
+        super(Efficient, self).__init__()
+        self.model = EfficientNet.from_pretrained("efficientnet-b3")
+        self.pool = nn.AdaptiveAvgPool2d((1,1))
+        self.fc = nn.Linear(1536, 256)
+        
+        self.reg_model = nn.Sequential(
+            nn.BatchNorm1d(256),
+            nn.Linear(256, 500),
+            nn.BatchNorm1d(500),
+            nn.Tanh(),
+            nn.Dropout(0.2),
+            nn.Linear(500, 100),
+            nn.BatchNorm1d(100),
+            nn.Tanh(),
+            nn.Dropout(0.2),
+            nn.Linear(100, 4),
+        )
+        
+    def forward(self, x):
+        x = self.model.extract_features(x)
+        x = self.pool(x)
+        x = x.view(-1, 1536)
+        x = self.fc(x)
+        x = self.reg_model(x)
+        return x
+    
+class ModelGradCam(nn.Module):
+    def __init__(self, base_model):
+        super(ModelGradCam, self).__init__()
+        
+        self.base_model = base_model
+        self.features_conv = self.base_model.model.extract_features
+        self.pool = self.base_model.pool
+        self.fc = self.base_model.fc
+        self.classifier = self.base_model.reg_model
+        self.gradients = None
+        
+    def activations_hook(self, grad):
+        self.gradients = grad
+    
+    def forward(self, x):
+        x = self.features_conv(x)
+        h = x.register_hook(self.activations_hook)
+        x = self.pool(x)
+        x = x.view(-1, 1536)
+        x = self.fc(x)
+        x = self.classifier(x)
+        return x
+    
+    def get_activations_gradient(self):
+        return self.gradients
+    
+    def get_activations(self, x):
+        return self.features_conv(x)
+    
+
+def plot_grad_cam(model, x_ray_image, class_names, normalized=True):
+    
+    model.eval()
+    # fig, axs = plt.subplots(1, 2, figsize=(15, 10))
+    
+    image = x_ray_image
+    outputs = torch.nn.functional.softmax(model(image), dim=1)
+    _, pred = torch.max(outputs, 1)
+    outputs[0][pred.detach().cpu().numpy()[0]].backward()
+    gradients = model.get_activations_gradient()
+    pooled_gradients = torch.mean(gradients, dim=[0, 2, 3])
+    activations = model.get_activations(image).detach()
+
+    activations *= pooled_gradients.unsqueeze(-1).unsqueeze(-1)
+    heatmap = torch.mean(activations, dim=1).squeeze()
+    heatmap = np.maximum(heatmap.cpu(), 0)
+    heatmap /= torch.max(heatmap)
+
+    img = image.squeeze().permute(1, 2, 0).cpu().numpy()
+    img = img if normalized else img/255.0
+    heatmap = cv2.resize(heatmap.numpy(), (img.shape[1], img.shape[0]))
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+        
+    superimposed_img = heatmap * 0.0025 + img
+    outputs = outputs.tolist()[0]
+    output_dict = dict(zip(class_names, np.round(outputs,3)))
+    return superimposed_img, class_names[pred.item()], output_dict
+    # axs[0].imshow(img)
+    # axs[1].imshow(superimposed_img)
+    # axs[0].set_title(f'Predicted: {class_names[pred.item()]}\n Confidence: {conf.item():.2f}')
+    # axs[0].axis('off')
+    # axs[1].set_title(f'Predicted: {class_names[pred.item()]}\n Confidence: {conf.item():.2f}')
+    # axs[1].axis('off')
+    # plt.show()
+

Utils/Covid19_Utils.py

@@ -0,0 +1,116 @@
+import cv2
+from PIL import Image
+import torch
+import matplotlib.pyplot as plt
+import torch.functional as F
+import torch.nn as nn
+import numpy as np
+import torchvision
+import torchvision.transforms as transforms
+
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+else:
+    device = torch.device("cpu")
+
+mean_nums = [0.485, 0.456, 0.406]
+std_nums = [0.229, 0.224, 0.225]
+
+val_transform = transforms.Compose([
+    transforms.Resize((150,150)),
+    transforms.CenterCrop(150), #Performs Crop at Center and resizes it to 150x150
+    transforms.ToTensor(),
+    transforms.Normalize(mean=mean_nums, std = std_nums)
+])
+
+def transform_image(image, transforms):
+    # img = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB)
+    img = transforms(image)
+    img = img.unsqueeze(0)
+    return img
+
+class DenseNet(nn.Module):
+    def __init__(self):
+        super(DenseNet, self).__init__()
+        self.base_model = torchvision.models.densenet121(weights="DEFAULT").features
+        self.pool = nn.AdaptiveAvgPool2d((1,1))
+        self.fc = nn.Linear(1024, 1000)
+        self.classify = nn.Linear(1000, 1)
+        self.classifier = nn.Sigmoid()
+        
+    def forward(self, x):
+        x = self.base_model(x)
+        x = self.pool(x)
+        x = x.view(-1, 1024)
+        x = self.fc(x)
+        x = self.classify(x)
+        x = self.classifier(x)
+        
+        return x
+
+class ModelGradCam(nn.Module):
+    def __init__(self, base_model):
+        super(ModelGradCam, self).__init__()
+        
+        self.features_conv = base_model.base_model
+        self.pool = base_model.pool
+        self.fc = base_model.fc
+        self.classify = base_model.classify
+        self.classifier = base_model.classifier
+        self.gradients = None
+        
+    def activations_hook(self, grad):
+        self.gradients = grad
+    
+    def forward(self, x):
+        x = self.features_conv(x)
+        h = x.register_hook(self.activations_hook)
+        x = self.pool(x)
+        x = x.view(-1, 1024)
+        x = self.fc(x)
+        x = self.classify(x)
+        x = self.classifier(x)
+        return x
+    
+    def get_activations_gradient(self):
+        return self.gradients
+    
+    def get_activations(self, x):
+        return self.features_conv(x)
+    
+def plot_grad_cam(model, x_ray_image, class_names, threshold:int=0.5, normalized=True):
+    
+    model.eval()
+    # fig, axs = plt.subplots(1, 2, figsize=(15, 10))
+    
+    image = x_ray_image
+    outputs = model(image).view(-1)
+    conf = [1-outputs.item(), outputs.item()]
+    # conf = 1 - outputs if outputs < threshold else outputs
+    pred = torch.where(outputs > threshold, torch.tensor(1, device=device), torch.tensor(0, device=device))
+    outputs[0].backward()
+    gradients = model.get_activations_gradient()
+    pooled_gradients = torch.mean(gradients, dim=[0, 2, 3])
+    activations = model.get_activations(image).detach()
+
+    activations *= pooled_gradients.unsqueeze(-1).unsqueeze(-1)
+    heatmap = torch.mean(activations, dim=1).squeeze()
+    heatmap = np.maximum(heatmap.cpu(), 0)
+    heatmap /= torch.max(heatmap)
+
+    img = image.squeeze().permute(1, 2, 0).cpu().numpy()
+    img = img if normalized else img/255.0
+    heatmap = cv2.resize(heatmap.numpy(), (img.shape[1], img.shape[0]))
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+        
+    superimposed_img = heatmap * 0.0045 + img
+    output_dict = dict(zip(class_names, np.round(conf,3)))
+    return superimposed_img, class_names[pred.item()], output_dict
+    # axs[0].imshow(img)
+    # axs[1].imshow(superimposed_img)
+    # axs[0].set_title(f'Predicted: {class_names[pred.item()]}\n Confidence: {conf.item():.3f}')
+    # axs[0].axis('off')
+    # axs[1].set_title(f'Predicted: {class_names[pred.item()]}\n Confidence: {conf.item():.3f}')
+    # axs[1].axis('off')
+    # plt.show()

Utils/DR_Utils.py

@@ -0,0 +1,207 @@
+import cv2
+from PIL import Image
+import torch
+import matplotlib.pyplot as plt
+import torch.functional as F
+import torch.nn as nn
+import numpy as np
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+# !pip install efficientnet_pytorch -q
+from efficientnet_pytorch import EfficientNet
+
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+else:
+    device = torch.device("cpu")
+
+val_transform = A.Compose(
+    [
+        A.Resize(height=300, width=300),
+        A.Normalize(
+            mean=[0.3199, 0.2240, 0.1609],
+            std=[0.3020, 0.2183, 0.1741],
+            max_pixel_value=255.0,
+        ),
+        ToTensorV2(),
+    ]
+)
+
+def transform_image(image_1, image_2, transforms):
+    # img_1 = cv2.cvtColor(cv2.imread(image_path_1), cv2.COLOR_BGR2RGB)
+    img_1 = transforms(image=np.array(image_1))['image']
+    img_1 = img_1.unsqueeze(0)
+    
+    # img_2 = cv2.cvtColor(cv2.imread(image_path_2), cv2.COLOR_BGR2RGB)
+    img_2 = transforms(image=np.array(image_2))['image']
+    img_2 = img_2.unsqueeze(0)
+    images = {'img1':img_1,'img2':img_2}
+    return images
+
+class BasicConv2d(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=False):
+        super(BasicConv2d, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size,stride=stride,padding=padding,bias=bias)
+        self.norm = nn.BatchNorm2d(out_channels, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+
+    def forward(self,x):
+        x = self.conv1(x)
+        x = self.norm(x)
+        return x
+
+
+
+class BottleNeck(nn.Module):
+    def __init__(self, prev_channels, in_channels, out_channels, kernel_size=3, stride=2, padding=1, reduce=False):
+        super(BottleNeck, self).__init__()
+        self.reduce = reduce
+
+        self.ReduceBlock1 = BasicConv2d(prev_channels, in_channels, kernel_size=1, stride=stride, padding=0)
+        self.ReduceBlock2 = BasicConv2d(prev_channels, out_channels, kernel_size=1, stride=stride, padding=0)
+
+        self.Block1 = BasicConv2d(prev_channels, in_channels, kernel_size=1, stride=1, padding=0)
+        self.Block2 = BasicConv2d(in_channels, in_channels, kernel_size=kernel_size, stride=1, padding=padding)
+        self.Block3 = BasicConv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
+        self.relu = nn.ReLU()
+
+    def forward(self, x):
+        out = x
+        if self.reduce:
+            out = self.ReduceBlock1(x)
+            out = self.relu(out)
+            identity = self.ReduceBlock2(x)
+        else:
+            out = self.Block1(out)
+            out = self.relu(out)
+        out = self.Block2(out)
+        out = self.relu(out)
+        out = self.Block3(out)
+        if self.reduce:
+            out = self.relu(out+identity)
+        
+        return out
+
+class ConvolutionNeuralNetwork(nn.Module):
+    def __init__(self, num_classes: int=1) -> nn.Module:
+        super(ConvolutionNeuralNetwork, self).__init__()
+        self.conv1 = BasicConv2d(3, 64, 7, 2, 3)
+        self.pool1 = nn.MaxPool2d(kernel_size=3,stride=2)
+
+        self.ResBlock2a = BottleNeck(64, 64, 256, 3, 1, 1, reduce=True)
+        self.ResBlock2b = BottleNeck(256, 64, 256, 3)
+        self.ResBlock2c = BottleNeck(256, 64, 256, 3)
+
+        self.avgpool = nn.AdaptiveAvgPool2d((1,1))
+        self.reg_model = nn.Sequential(
+            nn.BatchNorm1d(256* 2),
+            nn.Linear((256) * 2, 500),
+            nn.BatchNorm1d(500),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(500, 100),
+            nn.BatchNorm1d(100),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(100, 2),
+        )
+        
+    def forward(self, images):
+        img = self.conv1(images['img1'])
+        img = self.pool1(img)
+        img = self.ResBlock2a(img)
+        img = self.ResBlock2b(img)
+        img = self.ResBlock2c(img)
+        img = self.avgpool(img)
+        img = torch.flatten(img, 1)
+        
+        img1= self.conv1(images['img2'])
+        img1= self.pool1(img1)
+        img1= self.ResBlock2a(img1)
+        img1= self.ResBlock2b(img1)
+        img1= self.ResBlock2c(img1)
+        img1 = self.avgpool(img1)
+        img1 = torch.flatten(img1, 1)
+        
+        conc = torch.cat((img, img1), dim=1)
+        x = self.reg_model(conc)
+        
+        return x
+
+
+class Efficient(nn.Module):
+    def __init__(self, num_classes:int=1):
+        super(Efficient, self).__init__()
+        self.model = EfficientNet.from_pretrained("efficientnet-b3")
+        num_features = self.model._fc.in_features
+        self.model._fc = nn.Linear(num_features, 256)
+        
+        self.reg_model = nn.Sequential(
+            nn.BatchNorm1d(256* 2),
+            nn.Linear((256) * 2, 500),
+            nn.BatchNorm1d(500),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(500, 100),
+            nn.BatchNorm1d(100),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(100, 2),
+        )
+
+    def forward(self, images):
+        img1 = self.model(images['img1'])
+        img2 = self.model(images['img2'])
+        conc = torch.cat((img1,img2), dim=1)
+        x = self.reg_model(conc)
+        return x
+
+class EnsembleModel(nn.Module):
+    def __init__(self, model_cnn, model_eff):
+        super(EnsembleModel, self).__init__()
+        self.model_cnn = model_cnn
+        self.model_eff = model_eff
+        assert model_cnn.reg_model[-1].out_features == model_eff.reg_model[-1].out_features
+        # They both have same num_classes so we dont need to edit any code here for the fully connected layer
+        
+    def forward(self, images):
+        model_cnn_output = self.model_cnn(images)
+        model_res_output = self.model_eff(images)
+        ensemble_output = (model_cnn_output + model_res_output) / 2.0
+        # ensemble_output = torch.cat((model_cnn_output, model_res_output), dim=1)
+        return ensemble_output
+    
+def Inf_predict_image(model:nn.Module, images, class_names) -> None:
+    model.eval()
+    # fig, axs = plt.subplots(1, 2, figsize=(15, 10))
+
+    for img in images:
+        images[img] = images[img].to(device)
+        
+    predictions = model(images)
+            
+    # Convert MSE floats to integer predictions
+    predictions[predictions < 0.5] = 0
+    predictions[(predictions >= 0.5) & (predictions < 1.5)] = 1
+    predictions[(predictions >= 1.5) & (predictions < 2.5)] = 2
+    predictions[(predictions >= 2.5) & (predictions < 3.5)] = 3
+    predictions[(predictions >= 3.5) & (predictions < 10000000)] = 4
+    predictions = predictions.long().squeeze(1)
+    
+    image_1 = images['img1'].squeeze().permute(1, 2, 0).cpu().numpy()
+    image_2 = images['img2'].squeeze().permute(1, 2, 0).cpu().numpy()
+    
+    predicted_label1 = predictions[0][0].item()
+    predicted_label2 = predictions[0][1].item()
+
+    return class_names[predicted_label1], class_names[predicted_label2]
+    # axs[0].imshow(image_1)
+    # axs[1].imshow(image_2)
+    # axs[0].set_title(f'Predicted: ({class_names[predicted_label1]})')
+    # axs[1].set_title(f'Predicted: ({class_names[predicted_label2]})')
+    # axs[0].axis('off')
+    # axs[1].axis('off')
+
+    # plt.show()
+    
+    
+

Utils/Pneumonia_Utils.py

@@ -0,0 +1,99 @@
+import cv2
+from PIL import Image
+import torch
+import matplotlib.pyplot as plt
+import torch.functional as F
+import torch.nn as nn
+import numpy as np
+import torchvision
+import torchvision.transforms as transform
+# !pip install efficientnet_pytorch -q
+from efficientnet_pytorch import EfficientNet
+
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+else:
+    device = torch.device("cpu")
+
+val_transform = transform.Compose([transform.Resize(255),
+                                                 transform.CenterCrop(224),                                                              
+                                                 transform.ToTensor(),
+                                                ])
+
+def transform_image(image, transforms):
+    # img = cv2.cvtColor(cv2.imread(image_path), cv2.COLOR_BGR2RGB)
+    img = transforms(image)
+    img = img.unsqueeze(0)
+    return img
+
+DenseNet = torchvision.models.densenet161(weights="DEFAULT")
+for param in DenseNet.parameters():
+    param.requires_grad = True
+in_features = DenseNet.classifier.in_features
+DenseNet.classifier = nn.Linear(in_features, 2)
+
+
+
+class ModelGradCam(nn.Module):
+    def __init__(self, base_model):
+        super(ModelGradCam, self).__init__()
+        
+        self.base_model = base_model
+        self.features_conv = self.base_model.features
+        self.pool = nn.AdaptiveAvgPool2d((1,1))
+        self.classifier = self.base_model.classifier
+        self.gradients = None
+        
+    def activations_hook(self, grad):
+        self.gradients = grad
+    
+    def forward(self, x):
+        x = self.features_conv(x)
+        h = x.register_hook(self.activations_hook)
+        x = self.pool(x)
+        x = x.view(-1, 2208)
+        x = self.classifier(x)
+        return x
+    
+    def get_activations_gradient(self):
+        return self.gradients
+    
+    def get_activations(self, x):
+        return self.features_conv(x)
+    
+def plot_grad_cam(model, x_ray_image, class_names, normalized=True):
+    
+    model.eval()
+    # fig, axs = plt.subplots(1, 2, figsize=(15, 10))
+    
+    image = x_ray_image
+    outputs = torch.nn.functional.softmax(model(image), dim=1)
+    _, pred = torch.max(outputs, 1)
+    outputs[0][pred.detach().cpu().numpy()[0]].backward()
+    gradients = model.get_activations_gradient()
+    pooled_gradients = torch.mean(gradients, dim=[0, 2, 3])
+    activations = model.get_activations(image).detach()
+
+    activations *= pooled_gradients.unsqueeze(-1).unsqueeze(-1)
+    heatmap = torch.mean(activations, dim=1).squeeze()
+    heatmap = np.maximum(heatmap.cpu(), 0)
+    heatmap /= torch.max(heatmap)
+
+    img = image.squeeze().permute(1, 2, 0).cpu().numpy()
+    img = img if normalized else img/255.0
+    heatmap = cv2.resize(heatmap.numpy(), (img.shape[1], img.shape[0]))
+    heatmap = np.uint8(255 * heatmap)
+    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+        
+    superimposed_img = heatmap * 0.0025 + img
+    outputs = outputs.tolist()[0]
+    output_dict = dict(zip(class_names, np.round(outputs,3)))
+    return superimposed_img, class_names[pred.item()], output_dict
+    # axs[0].imshow(img)
+    # axs[1].imshow(superimposed_img)
+    # axs[0].set_title(f'Predicted: {class_names[pred.item()]}\n Confidence: {conf.item():.2f}')
+    # axs[0].axis('off')
+    # axs[1].set_title(f'Predicted: {class_names[pred.item()]}\n Confidence: {conf.item():.2f}')
+    # axs[1].axis('off')
+    # plt.show()
+

app.py

@@ -0,0 +1,164 @@
+import torch
+import os
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+from functools import partial
+
+import Utils.Pneumonia_Utils as PU
+import Utils.CT_Scan_Utils as CSU
+import Utils.Covid19_Utils as C19U
+import Utils.DR_Utils as DRU
+
+# Constants for model paths
+CANCER_MODEL_PATH = 'cs_models/EfficientNet_CT_Scans.pth.tar'
+DIABETIC_RETINOPATHY_MODEL_PATH = 'cs_models/model_DR_9.pth.tar'
+PNEUMONIA_MODEL_PATH = 'cs_models/DenseNet_Pneumonia.pth.tar'
+COVID_MODEL_PATH = 'cs_models/DenseNet_Covid.pth.tar'
+
+# Constants for class labels
+CANCER_CLASS_LABELS = ['adenocarcinoma','large.cell.carcinoma','normal','squamous.cell.carcinoma']
+DIABETIC_RETINOPATHY_CLASS_LABELS = ['No DR','Mild', 'Moderate', 'Severe', 'Proliferative DR']
+PNEUMONIA_CLASS_LABELS = ['Normal', 'Pneumonia']
+COVID_CLASS_LABELS = ['Normal','Covid19']
+
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+else:
+    device = torch.device("cpu")
+
+
+def cancer_page(image, test_model):
+    x_ray_image = CSU.transform_image(image, CSU.val_transform)
+    x_ray_image = x_ray_image.to(device)
+    grad_x_ray_image, pred_label, pred_conf = CSU.plot_grad_cam(test_model, 
+                                                                x_ray_image, 
+                                                                CANCER_CLASS_LABELS, 
+                                                                normalized=True)
+    grad_x_ray_image = np.clip(grad_x_ray_image, 0, 1)
+    return grad_x_ray_image, pred_label, pred_conf
+
+
+def covid_page(image, test_model):
+    x_ray_image = C19U.transform_image(image, C19U.val_transform)
+    x_ray_image = x_ray_image.to(device)
+    grad_x_ray_image, pred_label, pred_conf = C19U.plot_grad_cam(test_model, 
+                                                                x_ray_image, 
+                                                                COVID_CLASS_LABELS, 
+                                                                normalized=True)
+    grad_x_ray_image = np.clip(grad_x_ray_image, 0, 1)
+    return grad_x_ray_image, pred_label, pred_conf            
+
+
+def pneumonia_page(image, test_model):
+    x_ray_image = PU.transform_image(image, PU.val_transform)
+    x_ray_image = x_ray_image.to(device)
+    grad_x_ray_image, pred_label, pred_conf = PU.plot_grad_cam(test_model, 
+                                                               x_ray_image, 
+                                                               PNEUMONIA_CLASS_LABELS, 
+                                                               normalized=True)
+    grad_x_ray_image = np.clip(grad_x_ray_image, 0, 1)
+    return grad_x_ray_image, pred_label, pred_conf               
+
+def diabetic_retinopathy_page(image_1, image_2, test_model):
+    images = DRU.transform_image(image_1, image_2, DRU.val_transform)
+    pred_label_1, pred_label_2 = DRU.Inf_predict_image(test_model, 
+                                                        images, 
+                                                        DIABETIC_RETINOPATHY_CLASS_LABELS)
+    return pred_label_1, pred_label_2        
+
+CSU_model = CSU.Efficient().to(device)
+CSU_model.load_state_dict(torch.load(CANCER_MODEL_PATH,map_location=torch.device('cpu')),strict=False)
+CSU_test_model = CSU.ModelGradCam(CSU_model).to(device)
+CSU_images_dir = "TESTS/CHEST_CT_SCANS"
+all_images = os.listdir(CSU_images_dir)
+CSU_examples = [[os.path.join(CSU_images_dir,image)] for image in np.random.choice(all_images, size=4, replace=False)]
+
+C19U_model = C19U.DenseNet().to(device)
+C19U_model.load_state_dict(torch.load(COVID_MODEL_PATH,map_location=torch.device('cpu')),strict=False)
+C19U_test_model = C19U.ModelGradCam(C19U_model).to(device)
+C19U_C19_images_dir = [[os.path.join("TESTS/COVID19",image)] for image in np.random.choice(os.listdir("TESTS/COVID19"), size=2, replace=False)]
+NORM_images_dir = [[os.path.join("TESTS/NORMAL",image)] for image in np.random.choice(os.listdir("TESTS/NORMAL"), size=2, replace=False)]
+C19U_examples = C19U_C19_images_dir + NORM_images_dir
+
+PU_model = PU.DenseNet.to(device)
+PU_model.load_state_dict(torch.load(PNEUMONIA_MODEL_PATH,map_location=torch.device('cpu')),strict=False)
+PU_test_model = PU.ModelGradCam(PU_model).to(device)
+PU_images_dir = [[os.path.join("TESTS/PNEUMONIA",image)] for image in np.random.choice(os.listdir("TESTS/PNEUMONIA"), size=2, replace=False)]
+NORM_images_dir = [[os.path.join("TESTS/NORMAL",image)] for image in np.random.choice(os.listdir("TESTS/NORMAL"), size=2, replace=False)]
+PU_examples = PU_images_dir + NORM_images_dir
+
+DRU_cnn_model = DRU.ConvolutionNeuralNetwork().to(device)
+DRU_eff_b3 = DRU.Efficient().to(device)
+DRU_ensemble = DRU.EnsembleModel(DRU_cnn_model, DRU_eff_b3).to(device)
+DRU_ensemble.load_state_dict(torch.load(DIABETIC_RETINOPATHY_MODEL_PATH,map_location=torch.device('cpu'))["state_dict"], strict=False)
+DRU_test_model  = DRU_ensemble
+DRU_examples = [['TESTS/DR_1/10030_left._aug_0._aug_6.jpeg','TESTS/DR_0/10031_right._aug_17.jpeg']]
+
+demo = gr.Blocks(title="X-RAY_CLASSIFIER")
+
+with demo:
+
+    gr.Markdown(
+        """ # WELCOME, Try Out the X-ray_Classifier Below
+        Try out the following classification models below."""
+        )
+    
+    with gr.Tab("Chest Cancer"):
+        with gr.Row():
+            cancer_input = gr.Image(type="pil", label="Image")
+            cancer_output1 = gr.Image(type="numpy", label="Heatmap Image")
+        cancer_output2 = gr.Textbox(label="Labels Present")
+        cancer_output3 = gr.Label(label="Probabilities", show_label=False)
+        cancer_button = gr.Button("Predict")
+        cancer_examples = gr.Examples(CSU_examples, inputs=[cancer_input])
+        
+    with gr.Tab("Covid19"):
+        with gr.Row():
+            covid_input = gr.Image(type="pil", label="Image")
+            covid_output1 = gr.Image(type="numpy", label="Heatmap Image")
+        covid_output2 = gr.Textbox(label="Labels Present")
+        covid_output3 = gr.Label(label="Probabilities", show_label=False)
+        covid_button = gr.Button("Predict")
+        covid_examples = gr.Examples(C19U_examples, inputs=[covid_input])
+
+    with gr.Tab("Pneumonia"):
+        with gr.Row():
+            pneumonia_input = gr.Image(type="pil", label="Image")
+            pneumonia_output1 = gr.Image(type="numpy", label="Heatmap Image")
+        pneumonia_output2 = gr.Textbox(label="Labels Present")
+        pneumonia_output3 = gr.Label(label="Probabilities", show_label=False)
+        pneumonia_button = gr.Button("Predict")
+        pneumonia_examples = gr.Examples(PU_examples, inputs=[pneumonia_input])
+
+    with gr.Tab("Diabetic Retinopathy"):
+        with gr.Row():
+            dr_input1 = gr.Image(type="pil", label="Image")
+            dr_input2 = gr.Image(type="pil", label="Image")
+        dr_output1 = gr.Textbox(label="Labels Present")
+        dr_output2 = gr.Textbox(label="Labels Present")
+        dr_button = gr.Button("Predict")
+        dr_examples = gr.Examples(DRU_examples, inputs=[dr_input1, dr_input2])
+
+    cancer_button.click(partial(cancer_page, test_model=CSU_test_model), 
+                        inputs=cancer_input, 
+                        outputs=[cancer_output1, cancer_output2, cancer_output3])
+    
+    covid_button.click(partial(covid_page, test_model=C19U_test_model), 
+                       inputs=covid_input, 
+                       outputs=[covid_output1, covid_output2, covid_output3])
+    
+    pneumonia_button.click(partial(pneumonia_page, test_model=PU_test_model), 
+                           inputs=pneumonia_input, 
+                           outputs=[pneumonia_output1, pneumonia_output2, pneumonia_output3])
+    
+    dr_button.click(partial(diabetic_retinopathy_page, 
+                            test_model=DRU_test_model), 
+                            inputs=[dr_input1, dr_input2], 
+                            outputs=[dr_output1, dr_output2])
+
+
+if __name__ == "__main__":
+
+    demo.launch()

app_interface.py

@@ -0,0 +1,163 @@
+import torch
+import os
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+from functools import partial
+
+import Utils.Pneumonia_Utils as PU
+import Utils.CT_Scan_Utils as CSU
+import Utils.Covid19_Utils as C19U
+import Utils.DR_Utils as DRU
+
+# Constants for model paths
+CANCER_MODEL_PATH = 'cs_models/EfficientNet_CT_Scans.pth.tar'
+DIABETIC_RETINOPATHY_MODEL_PATH = 'cs_models/model_DR_9.pth.tar'
+PNEUMONIA_MODEL_PATH = 'cs_models/DenseNet_Pneumonia.pth.tar'
+COVID_MODEL_PATH = 'cs_models/DenseNet_Covid.pth.tar'
+
+# Constants for class labels
+CANCER_CLASS_LABELS = ['adenocarcinoma','large.cell.carcinoma','normal','squamous.cell.carcinoma']
+DIABETIC_RETINOPATHY_CLASS_LABELS = ['No DR','Mild', 'Moderate', 'Severe', 'Proliferative DR']
+PNEUMONIA_CLASS_LABELS = ['Normal', 'Pneumonia']
+COVID_CLASS_LABELS = ['Normal','Covid19']
+
+if torch.cuda.is_available():
+    device = torch.device("cuda")
+else:
+    device = torch.device("cpu")
+
+
+def cancer_page(image, test_model):
+    x_ray_image = CSU.transform_image(image, CSU.val_transform)
+    x_ray_image = x_ray_image.to(device)
+    grad_x_ray_image, pred_label, pred_conf = CSU.plot_grad_cam(test_model, 
+                                                                x_ray_image, 
+                                                                CANCER_CLASS_LABELS, 
+                                                                normalized=True)
+    grad_x_ray_image = np.clip(grad_x_ray_image, 0, 1)
+    return grad_x_ray_image, pred_label, pred_conf
+
+
+def covid_page(image, test_model):
+    x_ray_image = C19U.transform_image(image, C19U.val_transform)
+    x_ray_image = x_ray_image.to(device)
+    grad_x_ray_image, pred_label, pred_conf = C19U.plot_grad_cam(test_model, 
+                                                                x_ray_image, 
+                                                                COVID_CLASS_LABELS, 
+                                                                normalized=True)
+    grad_x_ray_image = np.clip(grad_x_ray_image, 0, 1)
+    return grad_x_ray_image, pred_label, pred_conf            
+
+
+def pneumonia_page(image, test_model):
+    x_ray_image = PU.transform_image(image, PU.val_transform)
+    x_ray_image = x_ray_image.to(device)
+    grad_x_ray_image, pred_label, pred_conf = PU.plot_grad_cam(test_model, 
+                                                               x_ray_image, 
+                                                               PNEUMONIA_CLASS_LABELS, 
+                                                               normalized=True)
+    grad_x_ray_image = np.clip(grad_x_ray_image, 0, 1)
+    return grad_x_ray_image, pred_label, pred_conf               
+
+def diabetic_retinopathy_page(image_1, image_2, test_model):
+    images = DRU.transform_image(image_1, image_2, DRU.val_transform)
+    pred_label_1, pred_label_2 = DRU.Inf_predict_image(test_model, 
+                                                        images, 
+                                                        DIABETIC_RETINOPATHY_CLASS_LABELS)
+    return pred_label_1, pred_label_2        
+
+if __name__ == "__main__":
+
+    CSU_model = CSU.Efficient().to(device)
+    CSU_model.load_state_dict(torch.load(CANCER_MODEL_PATH,map_location=torch.device('cpu')),strict=False)
+    CSU_test_model = CSU.ModelGradCam(CSU_model).to(device)
+    CSU_images_dir = "TESTS/CHEST_CT_SCANS"
+    all_images = os.listdir(CSU_images_dir)
+    CSU_examples = [[os.path.join(CSU_images_dir,image)] for image in np.random.choice(all_images, size=4, replace=False)]
+    
+    C19U_model = C19U.DenseNet().to(device)
+    C19U_model.load_state_dict(torch.load(COVID_MODEL_PATH,map_location=torch.device('cpu')),strict=False)
+    C19U_test_model = C19U.ModelGradCam(C19U_model).to(device)
+    C19U_C19_images_dir = [[os.path.join("TESTS/COVID19",image)] for image in np.random.choice(os.listdir("TESTS/COVID19"), size=2, replace=False)]
+    NORM_images_dir = [[os.path.join("TESTS/NORMAL",image)] for image in np.random.choice(os.listdir("TESTS/NORMAL"), size=2, replace=False)]
+    C19U_examples = C19U_C19_images_dir + NORM_images_dir
+
+    PU_model = PU.DenseNet.to(device)
+    PU_model.load_state_dict(torch.load(PNEUMONIA_MODEL_PATH,map_location=torch.device('cpu')),strict=False)
+    PU_test_model = PU.ModelGradCam(PU_model).to(device)
+    PU_images_dir = [[os.path.join("TESTS/PNEUMONIA",image)] for image in np.random.choice(os.listdir("TESTS/PNEUMONIA"), size=2, replace=False)]
+    NORM_images_dir = [[os.path.join("TESTS/NORMAL",image)] for image in np.random.choice(os.listdir("TESTS/NORMAL"), size=2, replace=False)]
+    PU_examples = PU_images_dir + NORM_images_dir
+
+    DRU_cnn_model = DRU.ConvolutionNeuralNetwork().to(device)
+    DRU_eff_b3 = DRU.Efficient().to(device)
+    DRU_ensemble = DRU.EnsembleModel(DRU_cnn_model, DRU_eff_b3).to(device)
+    DRU_ensemble.load_state_dict(torch.load(DIABETIC_RETINOPATHY_MODEL_PATH,map_location=torch.device('cpu'))["state_dict"], strict=False)
+    DRU_test_model  = DRU_ensemble
+    DRU_examples = [['TESTS/DR_1/10030_left._aug_0._aug_6.jpeg','TESTS/DR_0/10031_right._aug_17.jpeg']]
+
+    cancer_interface = gr.Interface(
+        fn=partial(cancer_page,test_model=CSU_test_model), 
+        inputs=gr.Image(type="pil", label="Image"),
+        outputs=[
+            gr.Image(type="numpy", label="Heatmap Image"),
+            gr.Textbox(label="Labels Present"),
+            gr.Label(label="Probabilities", show_label=False)
+        ],
+        examples=CSU_examples,
+        cache_examples=False,
+        allow_flagging="never",
+        title="Chest Cancer Detection System"
+    )
+
+    covid_interface = gr.Interface(
+        fn=partial(covid_page,test_model=C19U_test_model), 
+        inputs=gr.Image(type="pil", label="Image"),
+        outputs=[
+            gr.Image(type="numpy", label="Heatmap Image"),
+            gr.Textbox(label="Labels Present"),
+            gr.Label(label="Probabilities", show_label=False)
+        ],
+        examples=C19U_examples,
+        cache_examples=False,
+        allow_flagging="never",
+        title="Covid Detection System"
+    )
+
+    pneumonia_interface = gr.Interface(
+        fn=partial(pneumonia_page,test_model=PU_test_model), 
+        inputs=gr.Image(type="pil", label="Image"),
+        outputs=[
+            gr.Image(type="numpy", label="Heatmap Image"),
+            gr.Textbox(label="Labels Present"),
+            gr.Label(label="Probabilities", show_label=False)
+        ],
+        examples=PU_examples,
+        cache_examples=False,
+        allow_flagging="never",
+        title="Pneumonia Detection System"
+    )
+
+    diabetic_retinopathy_interface = gr.Interface(
+        fn=partial(diabetic_retinopathy_page,test_model=DRU_test_model), 
+        inputs=[gr.Image(type="pil", label="Image"), gr.Image(type="pil", label="Image")],
+        outputs=[
+            gr.Textbox(label="Labels Present"),
+            gr.Textbox(label="Labels Present")
+        ],
+        examples=DRU_examples,
+        cache_examples=False,
+        allow_flagging="never",
+        title="Diabetic Retinopathy System"
+    )
+
+    demo = gr.TabbedInterface(
+        [cancer_interface, 
+         covid_interface, 
+         pneumonia_interface, 
+         diabetic_retinopathy_interface], 
+         ["Chest Cancer", "Covid19", "Pneumonia", "Diabetic Retinopathy"])
+
+    demo.launch(share=True)

cs_models/DenseNet_Covid.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bb47891bf00093d9d4d8aaf4c5462bf0a90113c57576ab58f8a66c75075523e
+size 32421783

cs_models/DenseNet_Pneumonia.pth.tar

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

cs_models/EfficientNet_CT_Scans.pth.tar

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

cs_models/model_DR_9.pth.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5867469cd55865529bbdfb9a0fa01bff09797bbe23132cbb1d32585b8f2d15cc
+size 144866177

requirements.txt

@@ -0,0 +1,91 @@
+aiofiles==23.2.1
+albumentations==1.3.1
+altair==5.1.1
+annotated-types==0.5.0
+anyio==3.7.1
+attrs==23.1.0
+certifi==2023.7.22
+charset-normalizer==3.2.0
+click==8.1.7
+cmake==3.27.5
+contourpy==1.1.1
+cycler==0.11.0
+efficientnet-pytorch==0.7.1
+fastapi==0.103.1
+ffmpy==0.3.1
+filelock==3.12.4
+fonttools==4.42.1
+fsspec==2023.9.2
+gradio==3.44.4
+gradio_client==0.5.1
+h11==0.14.0
+httpcore==0.18.0
+httpx==0.25.0
+huggingface-hub==0.17.2
+idna==3.4
+imageio==2.31.3
+importlib-resources==6.1.0
+Jinja2==3.1.2
+joblib==1.3.2
+jsonschema==4.19.1
+jsonschema-specifications==2023.7.1
+kiwisolver==1.4.5
+lazy_loader==0.3
+lit==16.0.6
+MarkupSafe==2.1.3
+matplotlib==3.8.0
+mpmath==1.3.0
+networkx==3.1
+numpy==1.26.0
+nvidia-cublas-cu11==11.10.3.66
+nvidia-cuda-cupti-cu11==11.7.101
+nvidia-cuda-nvrtc-cu11==11.7.99
+nvidia-cuda-runtime-cu11==11.7.99
+nvidia-cudnn-cu11==8.5.0.96
+nvidia-cufft-cu11==10.9.0.58
+nvidia-curand-cu11==10.2.10.91
+nvidia-cusolver-cu11==11.4.0.1
+nvidia-cusparse-cu11==11.7.4.91
+nvidia-nccl-cu11==2.14.3
+nvidia-nvtx-cu11==11.7.91
+opencv-python==4.8.0.76
+opencv-python-headless==4.8.0.76
+orjson==3.9.7
+packaging==23.1
+pandas==2.1.1
+Pillow==10.0.1
+pydantic==2.3.0
+pydantic_core==2.6.3
+pydub==0.25.1
+pyparsing==3.1.1
+python-dateutil==2.8.2
+python-multipart==0.0.6
+pytz==2023.3.post1
+PyWavelets==1.4.1
+PyYAML==6.0.1
+qudida==0.0.4
+referencing==0.30.2
+requests==2.31.0
+rpds-py==0.10.3
+scikit-image==0.21.0
+scikit-learn==1.3.1
+scipy==1.11.2
+semantic-version==2.10.0
+six==1.16.0
+sniffio==1.3.0
+starlette==0.27.0
+sympy==1.12
+threadpoolctl==3.2.0
+tifffile==2023.9.18
+toolz==0.12.0
+torch==2.0.1
+torchvision==0.15.2
+tornado==6.3.3
+tqdm==4.66.1
+triton==2.0.0
+typing_extensions==4.8.0
+tzdata==2023.3
+urllib3==2.0.5
+uvicorn==0.23.2
+websockets==11.0.3
+wntr==1.0.0