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