Init

.gitignore

@@ -0,0 +1,3 @@
+project1_datdvt
+flagged
+__pycache__

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Dat Dao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

design/design.css

@@ -0,0 +1,102 @@
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+}
+
+.heading {
+    background-image: linear-gradient(45deg, #00B894, #56a0f0);
+    background-clip: text;
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    color: transparent;
+    font-size: 3.5em !important;
+    font-weight: bold;
+}
+
+.primary-button {
+    background: linear-gradient(90deg, #00B894, #56a0f0) !important;
+    border: none !important;
+    box-shadow: 0 4px 15px rgba(0, 184, 148, 0.2) !important;
+}
+
+.primary-button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 6px 20px rgba(0, 184, 148, 0.3) !important;
+}
+
+.results-container {
+    text-align: center;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    background: rgba(0, 184, 148, 0.1);
+    border-radius: 10px;
+    padding: 20px;
+}
+
+.confidence-high {
+    text-align: center;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    color: #00B894 !important;
+    font-weight: bold;
+}
+
+.confidence-medium {
+    text-align: center;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    color: #FFA502 !important;
+    font-weight: bold;
+}
+
+.confidence-low {
+    text-align: center;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    color: #FF4757 !important;
+    font-weight: bold;
+}
+
+.diagnosis-text {
+    font-size: 16px;
+    text-align: center;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    padding: 10px;
+    box-sizing: border-box;
+    border: None;
+    background-color: #2f3640;
+    color: #f5f6fa;
+}
+
+.image-controls {
+    background: rgba(9, 132, 227, 0.1);
+    border-radius: 8px;
+    padding: 15px;
+    margin-top: 10px;
+}
+
+.accordion {
+    border: none !important;
+    box-shadow: none !important;
+}
+
+.accordion:hover {
+    background: rgba(255, 255, 255, 0.05) !important;
+}
+
+[data-testid="image"] {
+    border: 2px ridge #00B894;
+    border-radius: 10px;
+    transition: all 0.3s ease;
+}
+
+[data-testid="image"]:hover {
+    border-color: #56a0f0;
+    box-shadow: 0 0 10px rgba(9, 132, 227, 0.3);
+}

interface.py

@@ -0,0 +1,126 @@
+import gradio as gr
+import torch.nn.functional as F
+import albumentations as A
+from pipeline import *
+
+def get_css(css_path):
+    with open(css_path, 'r') as f:
+        custom = f.read()
+    
+    return custom
+
+def create_interface():
+    custom = get_css('design/design.css')
+    processor = Pipeline()
+
+    with gr.Blocks(css=custom, theme=gr.themes.Soft(primary_hue='teal', secondary_hue='blue')) as interface:
+        with gr.Column(variant="compact"):
+            gr.Markdown("# Lungs Radiography Analysis", elem_classes='heading')
+            gr.Markdown("""
+                Upload/ Drop a chest X-ray image for COVID-19 diagnosis and analysis. 
+            """)
+        with gr.Row(equal_height=True):
+            # [UPLOAD IMAGE SECTION]
+            with gr.Column():
+                input_image = gr.Image(
+                    label="Upload Chest X-ray",
+                    height=400,
+                    elem_classes="upload-image"
+                )
+
+                # [BUTTON]
+                with gr.Row():
+                    submit_btn = gr.Button("Analyze Image", variant="primary", elem_classes='primary-button', scale=2)
+                    clear_btn = gr.Button('Clear', variant='secondary', scale=1)
+                    
+            with gr.Column():
+                with gr.Group(elem_classes='results-container'):                    
+                    output_image = gr.Image(
+                        label="COVID-19 Analysis",
+                        visible=False,
+                        height=400
+                    )
+
+                with gr.Row(equal_height=True):
+                    diagnosis_label = gr.Label(label="Diagnosis Conclusion", elem_classes='results-container')
+                    confidence_label = gr.Label(label="Confidence Score", elem_classes='results-container')
+                
+                with gr.Row():
+                    diagnosis_text = gr.Textbox(
+                                label="Diagnosis Details",
+                                visible=False,
+                                container=False
+                            )
+        
+        # [HELP SECTION]    
+        with gr.Accordion("Information", open=False):
+                    gr.Markdown("""
+                ### Tutorial
+                1. Click the upload button/ Drag and drop a chest X-ray image.
+                2. Choose 'Analyze Image'.
+                3. Review the results:
+                   - For COVID cases: View highlighted infection regions.
+                   - For Non-COVID/Healthy cases: Review detailed diagnosis text.
+            """)
+                    
+        def clear_inputs():
+            return {
+                input_image: None,
+                output_image: gr.update(visible=False),
+                diagnosis_text: gr.update(visible=False),
+                diagnosis_label: None,
+                confidence_label: None
+            }
+        
+        def handle_prediction(image, opacity=0.4):            
+            prediction, confidence, output_img, analysis_text = processor.process_image(
+                image, overlay_opacity=opacity
+            )
+            
+            confidence_class = (
+                "confidence-high" if confidence > 90
+                else "confidence-medium" if confidence > 70
+                else "confidence-low"
+            )
+            print(confidence_class)
+            
+            is_covid = output_img is not None
+            
+            return {
+                diagnosis_label: prediction,
+                confidence_label: gr.update(
+                    value=f"Confidence: {confidence:.2f}%",
+                    elem_classes=[confidence_class]
+                ),
+                output_image: gr.update(value=output_img, visible=is_covid),
+                diagnosis_text: gr.update(value=analysis_text, visible=True)
+            }
+
+        submit_btn.click(
+            fn=handle_prediction,
+            inputs=[input_image],
+            outputs=[
+                diagnosis_label,
+                confidence_label,
+                output_image,
+                diagnosis_text,
+            ]
+        )
+        
+        clear_btn.click(
+            fn=clear_inputs,
+            inputs=[],
+            outputs=[
+                input_image,
+                output_image,
+                diagnosis_text,
+                diagnosis_label,
+                confidence_label
+            ]
+        )
+        
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch(share=True)

models/classification_models/ResNet.py

@@ -0,0 +1,9 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+
+weights = models.ResNet50_Weights.DEFAULT
+resnet_model = models.resnet50(weights=weights)
+resnet_model.fc = nn.Linear(resnet_model.fc.in_features , 3)
+
+

models/segmentation_models/ResnetUnet.py

@@ -0,0 +1,84 @@
+import torch
+import torch.nn as nn
+import torchvision.models as models
+
+def basic_block(in_channels, out_channels):
+    block = nn.Sequential(
+        nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
+        nn.BatchNorm2d(out_channels),
+        nn.ReLU(inplace=True),
+        nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
+        nn.BatchNorm2d(out_channels),
+        nn.ReLU(inplace=True)
+    )
+    return block
+
+class DecoderBlock(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+        self.basic_block = basic_block(in_channels, out_channels)
+        self.up_sample = nn.ConvTranspose2d(in_channels - out_channels, in_channels - out_channels, 2, 2)
+    
+    def forward(self, down, skip):
+        x = self.up_sample(down)
+        x = torch.cat([x, skip], dim=1)
+        x = self.basic_block(x)
+        return x
+    
+class ResNetUnet(nn.Module):
+    def __init__(self, n_classes=1, freeze=True):
+        super().__init__()
+        backbone = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
+            
+        self.encoder1 = nn.Sequential(
+            backbone.conv1,
+            backbone.bn1,
+            backbone.relu
+        )
+        self.maxpool = backbone.maxpool
+        self.encoder2 = backbone.layer1
+        self.encoder3 = backbone.layer2
+        self.encoder4 = backbone.layer3
+        self.encoder5 = backbone.layer4
+        
+        if freeze:
+            self._freeze_backbone()
+            
+        self.decoder5 = DecoderBlock(2048 + 1024, 1024) 
+        self.decoder4 = DecoderBlock(1024 + 512, 512)    
+        self.decoder3 = DecoderBlock(512 + 256, 256)     
+        self.decoder2 = DecoderBlock(256 + 64, 64)
+        self.decoder1 = nn.Sequential(
+            nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2),
+            nn.Conv2d(32, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(inplace=True)
+        )
+        self.out = nn.Conv2d(32, n_classes, kernel_size=1)
+        
+    def _freeze_backbone(self):
+        layers = [self.encoder1, self.encoder2, self.encoder3, 
+                         self.encoder4, self.encoder5]
+        
+        for layer in layers:
+            for param in layer.parameters():
+                param.requires_grad = False
+                
+    def forward(self, x):
+        e1 = self.encoder1(x)
+        p1 = self.maxpool(e1)
+        e2 = self.encoder2(p1)
+        e3 = self.encoder3(e2)
+        e4 = self.encoder4(e3)
+        e5 = self.encoder5(e4)
+        
+        d5 = self.decoder5(e5, e4)  
+        d4 = self.decoder4(d5, e3)  
+        d3 = self.decoder3(d4, e2)  
+        d2 = self.decoder2(d3, e1) 
+        d1 = self.decoder1(d2)
+        out = self.out(d1)
+        
+        return out
+    
+ResNetUnetmodel_50 = ResNetUnet(n_classes=1, freeze=True)

pipeline.py

@@ -0,0 +1,89 @@
+import torch
+import torch.nn.functional as F
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+import cv2
+import numpy as np
+
+from models.classification_models.ResNet import *
+from models.segmentation_models.ResnetUnet import *
+
+class Pipeline:
+    def __init__(self, img_size=256):
+        self.transform = self._get_transforms(img_size)
+        self.classification_model, self.segmentation_model = self._load_models()
+        self.class_names = ['COVID', 'Non-COVID', 'Healthy']
+        
+    def _get_transforms(self, img_size):
+        return A.Compose([
+            A.LongestMaxSize(max_size=img_size),
+            A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            ToTensorV2(),
+        ])
+    
+    def _load_models(self):
+        classification_model = resnet_model
+        classification_model.load_state_dict(torch.load('weights/classification_models/resnet50.pt'))
+        classification_model.eval()
+
+        segmentation_model = ResNetUnet()
+        checkpoint = torch.load('weights/segmentation_models/ResNetUnet_best.pt')
+        segmentation_model.load_state_dict(checkpoint['model_state_dict'])
+        segmentation_model.eval()
+
+        return classification_model, segmentation_model
+    
+    def process_image(self, image, overlay_opacity=0.4):
+        if image is None:
+            return None, None, None, None
+   
+        image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
+        transformed = self.transform(image=image)
+        input_tensor = transformed['image'].unsqueeze(0)
+        
+        with torch.inference_mode():
+            outputs = self.classification_model(input_tensor)
+            probs = F.softmax(outputs, dim=1)
+            pred_class = torch.argmax(probs, dim=1).item()
+            confidence = probs[0][pred_class].item() * 100
+
+        prediction = self.class_names[pred_class]
+        
+        if prediction == 'COVID':
+            with torch.inference_mode():
+                output = self.segmentation_model(input_tensor)
+                output = torch.sigmoid(output)
+                output = output.squeeze().cpu().numpy()
+                binary_mask = (output > 0.5).astype(np.uint8) * 255
+
+                mask_resized = cv2.resize(binary_mask, (image.shape[1], image.shape[0]))
+ 
+                overlay = np.zeros_like(image)
+                overlay[mask_resized > 0] = [255, 0, 0]  
+                blended = cv2.addWeighted(image, 1, overlay, overlay_opacity, 0)
+                
+                analysis_text = (
+                    f"COVID-19 Detection Results:\n"
+                    f"• Infection detected with {confidence:.1f}% confidence\n"
+                    f"• Red overlay indicates areas of potential COVID-19 infection\n"
+                    f"• Recommended: Seek immediate medical attention"
+                )
+                return prediction, confidence, blended, analysis_text
+                
+        elif prediction == 'Non-COVID':
+            analysis_text = (
+                f"Non-COVID Lung Condition Detected:\n"
+                f"• Confidence: {confidence:.1f}%\n"
+                f"• Other lung abnormalities as pneumonia or lungs enlargement should be considered for further treatment\n"
+                f"• Recommended: Consult with healthcare provider for proper diagnosis"
+            )
+            return prediction, confidence, None, analysis_text
+            
+        else:  
+            analysis_text = (
+                f"Healthy Lung Scan Results:\n"
+                f"• Confidence: {confidence:.1f}%\n"
+                f"• No significant abnormalities detected :)\n"
+                f"• Regular check-ups and an apple a day is recommended"
+            )
+            return prediction, confidence, None, analysis_text

weights/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore