Project Pushed to HuggingFace

README.md

@@ -1,13 +1,154 @@
+# Chest Disease Detection Using Custom DenseNet-ViT (Hybrid) Architecture
+
+<br>
+<div style="display: flex; justify-content: space-between;">
+  <img src="https://github.com/SoubhikSinha/Chest-Disease-Detection-Using-Custom-DenseNet-ViT-Architecture/blob/main/Deploy-Test%20Images/4ceeb362df213ccf2c0b4d6388bba1_gallery.jpg" style="height: 200px; width: auto;">
+  <img src="https://github.com/SoubhikSinha/Chest-Disease-Detection-Using-Custom-DenseNet-ViT-Architecture/blob/main/Deploy-Test%20Images/642x361_SLIDE_4_What_Does_Lung_Cancer_Look_Like.jpg?raw=true" style="height: 200px; width: auto;">
+</div>
+
+
+Acknowledgements
+---
+I would like to express my heartfelt gratitude to the creators of the datasets used in this project : `Paul Timothy Mooney` for the *Chest X-Ray Pneumonia Dataset*, `Tawsifur Rahman` for the *Tuberculosis Chest X-Ray Dataset*, and `Mohamed Hanyyy` for the *Chest CT-Scan Images Dataset*, all available on Kaggle. Their invaluable contributions provided the foundation for the development of this project. I also extend my sincere thanks to my peers and mentors for their guidance, support, and feedback, which played a crucial role in the success of this project.
+
+<br>
+
+About the Project
+---
+This project focuses on developing an AI-driven medical image analysis system aimed at diagnosing three major thoracic diseases : *[Pneumonia](https://medlineplus.gov/pneumonia.html), [Tuberculosis](https://www.who.int/news-room/fact-sheets/detail/tuberculosis#:~:text=Tuberculosis%20(TB)%20is%20an%20infectious,been%20infected%20with%20TB%20bacteria.), and [Lung cancer](https://medlineplus.gov/lungcancer.html#:~:text=Lung%20cancer%20is%20cancer%20that,differently%20and%20are%20treated%20differently.)*. By leveraging advanced deep learning techniques, the system processes radiological images, including chest [X-rays](https://www.nibib.nih.gov/science-education/science-topics/x-rays#:~:text=X%2Drays%20are%20a%20form,and%20structures%20inside%20the%20body.) and [CT scan](https://my.clevelandclinic.org/health/diagnostics/4808-ct-computed-tomography-scan) images, to classify pathologies and provide probability estimates for each condition. The tool enhances diagnostic accuracy and efficiency, supporting healthcare professionals in clinical decision-making and showcasing the potential for integrating AI into modern medical workflows. To make the system more accessible, a user-friendly application based on the *[Gradio](https://www.gradio.app/)* framework is developed, allowing users to upload chest imaging data and receive real-time predictions with associated probabilities. The application provides probabilistic predictions for pneumonia and tuberculosis, and multi-class probabilistic predictions for lung cancer, acting as an intuitive interface that bridges complex AI models and clinical practice for both medical professionals and researchers.
+
+<br>
+
+Datasets
+---
+
+ - [Chest X-Ray Images for Pneumonia](https://www.kaggle.com/datasets/paultimothymooney/chest-xray-pneumonia) ▶️ Consists of 5,856 images, with 3,878 labeled as `infected` and 1,349 labeled as `normal`.
+ - [Chest X-Ray Images for Tuberculosis](https://www.kaggle.com/datasets/tawsifurrahman/tuberculosis-tb-chest-xray-dataset) ▶️ Contains 4,200 images, of which 700 are labeled as `infected` and 3,500 as `normal`.
+- [Chest CT-Scan Images](https://www.kaggle.com/datasets/mohamedhanyyy/chest-ctscan-images) ▶️ Comprises 1,000 CT-scan images, focusing on the classification of lung cancer types, specifically *[Adenocarcinoma](https://my.clevelandclinic.org/health/diseases/21652-adenocarcinoma-cancers), [Large Cell Carcinoma (LCC)](https://lcfamerica.org/about-lung-cancer/diagnosis/types/large-cell-carcinomas/), and [Squamous Cell Carcinoma (SCC)](https://www.skincancer.org/skin-cancer-information/squamous-cell-carcinoma/)*. 
+
+<br>
+
+Image Preprocessing Techniques
 ---
-title: ChestDiseaseDetection
-emoji: 🏆
-colorFrom: pink
-colorTo: purple
-sdk: gradio
-sdk_version: 5.9.1
-app_file: app.py
-pinned: false
-short_description: Chest Disease Detection (Custom DenseNet-ViT Architecture)
+1.  **Histogram Equalization** ▶️ A technique that enhances the contrast of an image by redistributing its pixel intensity values, making the histogram more uniform.
+    
+2.  **CLAHE (Contrast Limited Adaptive Histogram Equalization)** : A variant of histogram equalization that operates locally on small regions (tiles) of the image to prevent over-amplification of noise in homogeneous areas.
+    
+3.  **Gaussian Blur** ▶️ A smoothing technique used to reduce noise and detail in an image by applying a Gaussian filter, which averages pixel values based on their distance from the center.
+    
+4.  **Resizing with Anti-Aliasing** ▶️ A process of changing an image's dimensions while using anti-aliasing techniques to smooth the image and reduce visual distortion or pixelation.
+    
+5.  **Edge Enhancement (Sharpening)** ▶️ A technique used to enhance the edges of objects in an image by amplifying high-frequency components, making them more distinct.
+    
+6.  **Intensity Normalization** ▶️ A method of adjusting the pixel values of an image to a specific range, typically [0, 1] or [0, 255], to standardize the image intensity for further processing.
+    
+7.  **Tensor Conversion and Normalization to [-1, 1] Range** ▶️ The process of converting image data into a tensor format and normalizing pixel values to a range of [-1, 1] for neural network compatibility and improved model performance.
+    
+8.  **Brightness and Contrast** ▶️ Techniques that adjust the overall brightness (lightness) and contrast (difference between light and dark areas) of an image to enhance visual clarity or correct lighting conditions.
+
+<br>
+
+DenseNet-ViT Hybrid Architecture
 ---
+The `LightweightHybridDenseNetViT` architecture combines a [DenseNet](https://arxiv.org/abs/1608.06993) backbone with a simplified [Vision Transformer (ViT)](https://arxiv.org/abs/2010.11929) module for tasks like pneumonia, tuberculosis, and lung cancer classification. Below is a detailed breakdown of each component of the architecture :
+
+### 1. **DenseNet Backbone (`self.densenet`)** :
+
+-   **DenseNet-121** : This is a pretrained model from the `torchvision` library, specifically [DenseNet121](https://pytorch.org/vision/main/models/generated/torchvision.models.densenet121.html). DenseNet is a type of convolutional neural network where each layer receives input from all previous layers, facilitating feature reuse and mitigating the vanishing gradient problem.
+-   **Feature Extraction** : The DenseNet is used primarily as a feature extractor. The model is loaded without pretrained weights (`pretrained=False`), and it outputs a rich set of features which are passed to subsequent layers.
+
+### 2. **Feature Channel Reduction (`self.conv_reduce`)** :
+
+-   **1x1 Convolution Layer** : After passing through DenseNet, the feature maps are typically high-dimensional (e.g., 1024 channels). To reduce the number of channels, a 1x1 convolution (`self.conv_reduce`) is applied, which reduces the 1024 channels down to 64. This reduction helps in minimizing the computational complexity and is a necessary step before passing the feature maps to the transformer module.
+
+### 3. **Simplified Vision Transformer (`self.vit`)** :
+
+-   **Simplified ViT Module** : A Vision Transformer (ViT) is used for processing the feature maps from DenseNet. ViTs operate on sequences of patches extracted from an image and learn relationships between these patches. However, in this case, a **simplified ViT** module is employed to reduce the complexity compared to traditional ViTs.
+    -   **TransformerEncoderLayer** : Each ViT block contains a `TransformerEncoderLayer`, which performs self-attention and then a feed-forward transformation (MLP - Multi-Level Perceptron). The ViT module here uses a smaller model with only 1 layer (`num_layers=1`), 2 attention heads (`num_heads=2`), and a smaller hidden dimension of 128 (`mlp_dim=128`).
+    -   **Flattening and Reshaping** : Before passing the input feature map through the transformer, the input tensor is flattened to a sequence of tokens (patches) by using the `x.flatten(2).permute(2, 0, 1)` operation. This transforms the feature map from the shape `(B, C, H, W)` into a sequence that the transformer can process. After the transformer processes this sequence, the result is reshaped back into the spatial dimensions of the input.
+
+### 4. **Global Average Pooling (GAP)** :
+
+-   **Pooling across Spatial Dimensions** : The output from the ViT module is a set of feature maps with dimensions `(B, C, H, W)`. To summarize this spatial information, **Global Average Pooling (GAP)** is applied (`x.mean(dim=[2, 3])`). GAP calculates the average of each feature map across the spatial dimensions (`H` and `W`), resulting in a vector of size `(B, C)`, where `C` is the number of channels (64 in this case). This operation reduces the spatial resolution, allowing the model to focus on the global features in the image.
+
+### 5. **Task-Specific Classification Heads** :
+
+After the feature maps are pooled, the resulting vector is passed to three different fully connected (FC) layers for classification:
+
+-   **Pneumonia Output (`self.fc_pneumonia`)** : A single output neuron with a sigmoid activation function, indicating a binary classification for pneumonia (0 or 1). The output is passed through the sigmoid activation to produce a probability.
+-   **Tuberculosis Output (`self.fc_tuberculosis`)** : Similar to the pneumonia output, this FC layer also has a single output neuron for binary classification of tuberculosis.
+-   **Lung Cancer Output (`self.fc_lung_cancer`)** : This output head has 4 output neurons, which corresponds to a multi-class classification task for lung cancer. The model outputs raw logits (scores for each class), which can be used for multi-class classification tasks.
+
+### 6. **Forward Pass** :
+
+-   **Input Processing** : The input image `x` is passed through DenseNet’s convolutional layers to extract feature maps.
+-   **Feature Reduction** : A 1x1 convolution reduces the number of output channels.
+-   **Transformer Processing** : The reduced feature maps are passed through the simplified Vision Transformer.
+-   **Pooling** : Global Average Pooling is applied to the output of the transformer.
+-   **Classification** : The pooled features are passed through the task-specific classification heads to produce predictions for pneumonia, tuberculosis, and lung cancer.
+
+### Summary of Workflow :
+
+1.  **DenseNet** extracts features from the input image.
+2.  **Conv1x1 layer** reduces the number of output channels.
+3.  **Simplified ViT** module processes the features, learning long-range dependencies between patches.
+4.  **Global Average Pooling** aggregates spatial information.
+5.  **Classification heads** output predictions for multiple tasks (pneumonia, tuberculosis, lung cancer).
+
+This architecture efficiently combines the strengths of both DenseNet (feature reuse and deep representations) and Vision Transformers (modeling long-range dependencies), while keeping the model lightweight and computationally feasible for real-time or resource-constrained applications.
+
+<br>
+
+How to run the project ?
+---
+### **1. Clone the Repository**
+Clone the repository to your local machine :<br>
+```bash
+git clone https://github.com/SoubhikSinha/Chest-Disease-Detection-Using-Custom-DenseNet-ViT-Architecture.git
+```
+### **2. Virtual Environment (Creation + Activation)**
+
+Navigate to the repository's root directory and create a Conda virtual environment :<br>
+```bash
+cd Chest-Disease-Detection-Using-Custom-DenseNet-ViT-Architecture
+./create.sh
+```
+<br>
+
+This will :
+
+-   Create a Conda environment (`Chest_Disease`)
+-   Activate the environment
+-   Install the required dependencies listed in `requirements.txt`
+
+**NOTE** : You may execute these commands in your machine's default CLI tool **if it supports scripting language files (.sh)**. If you encounter issues (especially on Windows), you may need to execute the commands using [Git Bash](https://git-scm.com/downloads). Ensure that you are running Git Bash from the **root directory** of the cloned repository.
+<br>
+If the `.sh` script execution isn't working in your default CLI, try the following steps in **Git Bash** :
+
+1.  Install Git Bash from the link above.
+2.  Open Git Bash and navigate to the repository directory.
+3.  Execute the commands in the terminal within Git Bash.
+
+Alternatively, if you don't want to rely on `.sh` scripts, you can manually execute the necessary steps :
+```bash
+conda create --name Chest_Disease python=3.x -y
+conda activate Chest_Disease
+pip install -r requirements.txt
+```
+
+### **3. Running the Project**
+Once your environment is set up, you can run the project and start the Gradio-based web application by executing the following command :<br>
+```bash
+./run.sh
+```
+<br>
+
+
+Alternatively, you can run the commands manually by executing :
+```bash
+conda activate Chest_Disease
+python final_project_Gradio_App.py
+```
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+### **4. Accessing the Gradio Web Application**
+Once the application starts, it will provide a link to the Gradio interface (usually something like `http://x.x.x.x:7860/`). Open this URL in your browser to interact with the web application.

create.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+# Checking if requirements.txt exists
+if [ ! -f requirements.txt ]; then
+    echo "Error: requirements.txt not found! Please ensure it exists in the current directory."
+    exit 1
+fi
+
+# Defining the environment name
+env_name="Chest_Disease"
+
+# Creating the conda environment
+conda create --name "$env_name" --yes python=3.11
+if [ $? -ne 0 ]; then
+    echo "Error: Failed to create the conda environment."
+    exit 1
+fi
+
+echo "Conda environment '$env_name' created successfully."
+
+# Activating the environment
+source $(conda info --base)/etc/profile.d/conda.sh
+conda activate "$env_name"
+if [ $? -ne 0 ]; then
+    echo "Error: Failed to activate the conda environment."
+    exit 1
+fi
+
+echo "Conda environment '$env_name' activated."
+
+# Installing dependencies from requirements.txt
+pip install -r requirements.txt
+if [ $? -ne 0 ]; then
+    echo "Error: Failed to install dependencies from requirements.txt."
+    exit 1
+fi
+
+echo "Dependencies installed successfully."
+echo "Your conda environment '$env_name' is ready and activated."

final_project_Gradio_App.py

@@ -0,0 +1,232 @@
+# Let us first import all the necessary libraries required for this project
+
+import tensorflow as tf
+import torch
+import cv2
+import sklearn
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+from torchvision import datasets, transforms, models
+from torch.utils.data import DataLoader, Dataset
+import torch.nn as nn
+import torch.optim as optim
+import torchvision
+import torch.nn.functional as F
+from PIL import Image
+
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix, roc_curve, auc
+
+
+# Later on, as per requirement, more libraries wil be imported
+
+import gradio as gr
+
+def adjust_brightness_contrast(image, alpha=1.2, beta=50):
+    """
+    Adjusting brightness and contrast of the image.
+    Parameters:
+        - image: Input image (numpy array).
+        - alpha: Contrast control [1.0-3.0].
+        - beta: Brightness control [0-100].
+    Returns:
+        - Adjusted image.
+    """
+    return cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
+
+def apply_histogram_equalization(image):
+    """Applying histogram equalization to enhance contrast."""
+    channels = cv2.split(image)
+    eq_channels = [cv2.equalizeHist(ch) for ch in channels]
+    return cv2.merge(eq_channels)
+
+def apply_clahe(image, clip_limit=2.0, tile_grid_size=(8, 8)):
+    """Applying CLAHE for local contrast enhancement."""
+    clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)
+    channels = cv2.split(image)
+    clahe_channels = [clahe.apply(ch) for ch in channels]
+    return cv2.merge(clahe_channels)
+
+def apply_gaussian_blur(image, kernel_size=(3, 3)):
+    """Applying Gaussian blur for denoising."""
+    return cv2.GaussianBlur(image, kernel_size, 0)
+
+def apply_sharpening(image):
+    """Applying edge enhancement using a sharpening filter."""
+    kernel = np.array([[0, -1, 0],
+                       [-1, 5, -1],
+                       [0, -1, 0]])
+    return cv2.filter2D(image, -1, kernel)
+
+def normalize_image(image):
+    """Normalizing the image to zero mean and unit variance."""
+    image = (image - np.mean(image)) / np.std(image)
+    return image
+
+def resize_image(image, width, height):
+    """Resizing the image to the desired dimensions with anti-aliasing."""
+    return cv2.resize(image, (width, height), interpolation=cv2.INTER_CUBIC)
+
+
+def preprocess_single_image(pil_image, img_height=224, img_width=224):
+    """
+    Preprocessing a single image as per the training pipeline.
+    Parameters:
+        - pil_image: Input PIL image.
+        - img_height, img_width: Dimensions to resize the image.
+    Returns:
+        - Preprocessed image tensor.
+    """
+    # Converting PIL image to numpy array
+    image = np.array(pil_image)
+
+    # Ensuring the image is in RGB format
+    if len(image.shape) == 2 or image.shape[2] == 1:  # Grayscale image
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+
+    # Applying preprocessing steps
+    image = apply_histogram_equalization(image)
+    image = apply_clahe(image)
+    image = apply_gaussian_blur(image)
+    image = apply_sharpening(image)
+    image = adjust_brightness_contrast(image, alpha=1.2, beta=50)
+
+    # Resizing and normalization
+    image = resize_image(image, img_width, img_height)
+    image = normalize_image(image)
+
+    # Converting to PIL image and applying transformations
+    image = Image.fromarray(image.astype(np.uint8))
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+    image_tensor = transform(image).unsqueeze(0)  # Adding batch dimension
+    return image_tensor
+
+
+# Detecting GPU if available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+from torchvision.models import densenet121
+from torchvision.transforms import Resize
+
+# Simplified ViT-like transformer module
+class SimpleViT(nn.Module):
+    def __init__(self, input_dim, num_heads, mlp_dim, num_layers):
+        super(SimpleViT, self).__init__()
+        # Reduced TransformerEncoder layer complexity
+        self.transformer_blocks = nn.ModuleList([
+            nn.TransformerEncoderLayer(
+                d_model=input_dim,
+                nhead=num_heads,
+                dim_feedforward=mlp_dim,
+                dropout=0.1
+            ) for _ in range(num_layers)
+        ])
+
+    def forward(self, x):
+        # Flattening the spatial dimensions
+        B, C, H, W = x.shape
+        x = x.flatten(2).permute(2, 0, 1)  # Reshaping for transformer
+        for block in self.transformer_blocks:
+            x = block(x)
+        x = x.permute(1, 2, 0).reshape(B, C, H, W)  # Restoring the original shape
+        return x
+
+
+# Adjusted Hybrid DenseNet + Simplified ViT Architecture
+class LightweightHybridDenseNetViT(nn.Module):
+    def __init__(self):
+        super(LightweightHybridDenseNetViT, self).__init__()
+
+        # Loading a lighter DenseNet backbone
+        self.densenet = densenet121(pretrained=False)  # Base DenseNet backbone
+
+        # Reducing the output channels from DenseNet to smaller dimensions
+        self.conv_reduce = nn.Conv2d(1024, 64, kernel_size=1)  # Fewer channels
+
+        # ViT processing module with reduced complexity
+        self.vit = SimpleViT(input_dim=64, num_heads=2, mlp_dim=128, num_layers=1)
+
+        # Task-specific classification heads
+        self.fc_pneumonia = nn.Linear(64, 1)  # Binary classification (Pneumonia)
+        self.fc_tuberculosis = nn.Linear(64, 1)  # Binary classification (Tuberculosis)
+        self.fc_lung_cancer = nn.Linear(64, 4)  # Multi-class output (Lung Cancer)
+
+    def forward(self, x):
+        # Extracting DenseNet features
+        x = self.densenet.features(x)  # Extracting DenseNet feature maps
+        x = self.conv_reduce(x)  # Reducing the number of feature channels
+
+        # Passing through simplified ViT module
+        x = self.vit(x)
+
+        # Applying Global Average Pooling (GAP)
+        x = x.mean(dim=[2, 3])  # Pooling across spatial dimensions
+
+        # Task-specific classification
+        pneumonia_output = torch.sigmoid(self.fc_pneumonia(x))  # Binary sigmoid output
+        tuberculosis_output = torch.sigmoid(self.fc_tuberculosis(x))  # Binary sigmoid output
+        lung_cancer_output = self.fc_lung_cancer(x)  # Multi-class logits
+
+        return pneumonia_output, tuberculosis_output, lung_cancer_output
+    
+
+# Loading the saved model
+img_size = 224  # Matching the dimensions used during training
+patch_size = 8
+
+
+model = LightweightHybridDenseNetViT().to(device)
+
+model.load_state_dict(torch.load("model_FINAL.pth", map_location=device))  # Mapping to the correct device
+model.to(device)  # Moving the model to GPU/CPU
+model.eval()  # Setting to evaluation mode
+
+
+# Function to pre-process the image and perform inference
+def predict_image(image):
+    """
+    Predicts the probabilities of Pneumonia, TB, and Lung Cancer from the input image.
+    """
+    # Preprocessing the image
+    image_tensor = preprocess_single_image(image, img_height=224, img_width=224)
+    image_tensor = image_tensor.to(device)
+    
+    # Performing inference
+    with torch.no_grad():
+        pneumonia_output, tb_output, lung_cancer_output = model(image_tensor)
+    
+    # Getting the probabilities
+    pneumonia_prob = pneumonia_output.item()
+    tb_prob = tb_output.item()
+    lung_cancer_probs = F.softmax(lung_cancer_output, dim=1).squeeze().tolist()
+
+    # Class names for lung cancer
+    lung_cancer_classes = [
+        "adenocarcinoma_left.lower.lobe",
+        "large.cell.carcinoma_left.hilum",
+        "NORMAL",
+        "squamous.cell.carcinoma_left.hilum"
+    ]
+    
+    # Preparing the result as a dictionary
+    result = {
+        "Pneumonia Probability": f"{pneumonia_prob:.4f}",
+        "TB Probability": f"{tb_prob:.4f}",
+        "Lung Cancer Probabilities": {class_name: f"{prob:.4f}" for class_name, prob in zip(lung_cancer_classes, lung_cancer_probs)}
+    }
+    
+    return result
+
+# Gradio Interface
+iface = gr.Interface(fn=predict_image, 
+                     inputs=gr.Image(type="pil"), 
+                     outputs=gr.JSON(),
+                     title="Probabilistic Lung Disease Detection",
+                     description="An AI-powered tool that analyzes and predicts probabilities for lung diseases, including Pneumonia, Tuberculosis, and Lung Cancer.")
+
+iface.launch()

final_project_deploy_local.ipynb

@@ -0,0 +1,1162 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Y2EgzZ7x4wEO"
+      },
+      "source": [
+        "#### **PROJECT TITLE :** `AI-Powered Medical Image Analysis Tool for Chest (X-Ray and CT-Scan) Diseases Detection`\n",
+        "\n",
+        "<br>\n",
+        "<br>\n",
+        "\n",
+        "### Component : `Model Deployment + Testing on Random Images`"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "1TmpNqBc1-Y2"
+      },
+      "outputs": [],
+      "source": [
+        "# Let us first import all the necessary libraries required for this project\n",
+        "\n",
+        "import tensorflow as tf\n",
+        "import torch\n",
+        "import cv2\n",
+        "import sklearn\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "import os\n",
+        "from torchvision import datasets, transforms, models\n",
+        "from torch.utils.data import DataLoader, Dataset\n",
+        "import torch.nn as nn\n",
+        "import torch.optim as optim\n",
+        "import torchvision\n",
+        "import torch.nn.functional as F\n",
+        "from PIL import Image\n",
+        "\n",
+        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix, roc_curve, auc\n",
+        "\n",
+        "\n",
+        "# Later on, as per requirement, more libraries wil be imported"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wnk9WBze56wW"
+      },
+      "source": [
+        "<br>\n",
+        "<br>\n",
+        "\n",
+        "### <b>STEP - 1 : Pre-Processing Functions</b>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "fdXDwKiV5HFK"
+      },
+      "outputs": [],
+      "source": [
+        "def adjust_brightness_contrast(image, alpha=1.2, beta=50):\n",
+        "    \"\"\"\n",
+        "    Adjusting brightness and contrast of the image.\n",
+        "    Parameters:\n",
+        "        - image: Input image (numpy array).\n",
+        "        - alpha: Contrast control [1.0-3.0].\n",
+        "        - beta: Brightness control [0-100].\n",
+        "    Returns:\n",
+        "        - Adjusted image.\n",
+        "    \"\"\"\n",
+        "    return cv2.convertScaleAbs(image, alpha=alpha, beta=beta)\n",
+        "\n",
+        "def apply_histogram_equalization(image):\n",
+        "    \"\"\"Applying histogram equalization to enhance contrast.\"\"\"\n",
+        "    channels = cv2.split(image)\n",
+        "    eq_channels = [cv2.equalizeHist(ch) for ch in channels]\n",
+        "    return cv2.merge(eq_channels)\n",
+        "\n",
+        "def apply_clahe(image, clip_limit=2.0, tile_grid_size=(8, 8)):\n",
+        "    \"\"\"Applying CLAHE for local contrast enhancement.\"\"\"\n",
+        "    clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)\n",
+        "    channels = cv2.split(image)\n",
+        "    clahe_channels = [clahe.apply(ch) for ch in channels]\n",
+        "    return cv2.merge(clahe_channels)\n",
+        "\n",
+        "def apply_gaussian_blur(image, kernel_size=(3, 3)):\n",
+        "    \"\"\"Applying Gaussian blur for denoising.\"\"\"\n",
+        "    return cv2.GaussianBlur(image, kernel_size, 0)\n",
+        "\n",
+        "def apply_sharpening(image):\n",
+        "    \"\"\"Applying edge enhancement using a sharpening filter.\"\"\"\n",
+        "    kernel = np.array([[0, -1, 0],\n",
+        "                       [-1, 5, -1],\n",
+        "                       [0, -1, 0]])\n",
+        "    return cv2.filter2D(image, -1, kernel)\n",
+        "\n",
+        "def normalize_image(image):\n",
+        "    \"\"\"Normalizing the image to zero mean and unit variance.\"\"\"\n",
+        "    image = (image - np.mean(image)) / np.std(image)\n",
+        "    return image\n",
+        "\n",
+        "def resize_image(image, width, height):\n",
+        "    \"\"\"Resizing the image to the desired dimensions with anti-aliasing.\"\"\"\n",
+        "    return cv2.resize(image, (width, height), interpolation=cv2.INTER_CUBIC)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jRUZ008d6p1T"
+      },
+      "source": [
+        "<br>\n",
+        "<br>\n",
+        "\n",
+        "### <b>STEP - 2 : Pre-processing Pipeline</b>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "KgcX83yc40g-"
+      },
+      "outputs": [],
+      "source": [
+        "def preprocess_single_image(img_path, img_height=224, img_width=224):\n",
+        "    \"\"\"\n",
+        "    Preprocessing a single image as per the training pipeline.\n",
+        "    \"\"\"\n",
+        "    # Loading image in BGR format\n",
+        "    image = cv2.imread(img_path, cv2.IMREAD_COLOR)\n",
+        "    if image is None:\n",
+        "        raise ValueError(f\"Image not found: {img_path}\")\n",
+        "\n",
+        "    # Converting BGR to RGB\n",
+        "    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+        "\n",
+        "    # Applying preprocessing steps\n",
+        "    image = apply_histogram_equalization(image)\n",
+        "    image = apply_clahe(image)\n",
+        "    image = apply_gaussian_blur(image)\n",
+        "    image = apply_sharpening(image)\n",
+        "    image = adjust_brightness_contrast(image, alpha=1.2, beta=50)\n",
+        "\n",
+        "    # Resizing and normalize\n",
+        "    image = resize_image(image, img_width, img_height)\n",
+        "    image = normalize_image(image)\n",
+        "\n",
+        "    # Converting to PIL image and applyinh transformations\n",
+        "    image = Image.fromarray(image.astype(np.uint8))\n",
+        "    transform = transforms.Compose([\n",
+        "        transforms.ToTensor(),\n",
+        "        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n",
+        "    ])\n",
+        "    image_tensor = transform(image).unsqueeze(0)  # Adding batch dimension\n",
+        "    return image_tensor"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0KLCcPYa6x_3"
+      },
+      "source": [
+        "<br>\n",
+        "<br>\n",
+        "\n",
+        "### <b>STEP - 3 : Loading the Model</b>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "hfTSNNQR8Gsu",
+        "outputId": "ef8a7e0b-25e5-4a00-d6e0-70bde079b08c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Using device: cuda\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Detecting GPU if available\n",
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "print(f\"Using device: {device}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "6tvYopjB7OAS"
+      },
+      "outputs": [],
+      "source": [
+        "from torchvision.models import densenet121\n",
+        "from torchvision.transforms import Resize\n",
+        "\n",
+        "# Simplified ViT-like transformer module\n",
+        "class SimpleViT(nn.Module):\n",
+        "    def __init__(self, input_dim, num_heads, mlp_dim, num_layers):\n",
+        "        super(SimpleViT, self).__init__()\n",
+        "        # Reduced TransformerEncoder layer complexity\n",
+        "        self.transformer_blocks = nn.ModuleList([\n",
+        "            nn.TransformerEncoderLayer(\n",
+        "                d_model=input_dim,\n",
+        "                nhead=num_heads,\n",
+        "                dim_feedforward=mlp_dim,\n",
+        "                dropout=0.1\n",
+        "            ) for _ in range(num_layers)\n",
+        "        ])\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        # Flattening the spatial dimensions\n",
+        "        B, C, H, W = x.shape\n",
+        "        x = x.flatten(2).permute(2, 0, 1)  # Reshaping for transformer\n",
+        "        for block in self.transformer_blocks:\n",
+        "            x = block(x)\n",
+        "        x = x.permute(1, 2, 0).reshape(B, C, H, W)  # Restoring the original shape\n",
+        "        return x\n",
+        "\n",
+        "\n",
+        "# Adjusted Hybrid DenseNet + Simplified ViT Architecture\n",
+        "class LightweightHybridDenseNetViT(nn.Module):\n",
+        "    def __init__(self):\n",
+        "        super(LightweightHybridDenseNetViT, self).__init__()\n",
+        "\n",
+        "        # Loading a lighter DenseNet backbone\n",
+        "        self.densenet = densenet121(pretrained=False)  # Base DenseNet backbone\n",
+        "\n",
+        "        # Reducing the output channels from DenseNet to smaller dimensions\n",
+        "        self.conv_reduce = nn.Conv2d(1024, 64, kernel_size=1)  # Fewer channels\n",
+        "\n",
+        "        # ViT processing module with reduced complexity\n",
+        "        self.vit = SimpleViT(input_dim=64, num_heads=2, mlp_dim=128, num_layers=1)\n",
+        "\n",
+        "        # Task-specific classification heads\n",
+        "        self.fc_pneumonia = nn.Linear(64, 1)  # Binary classification (Pneumonia)\n",
+        "        self.fc_tuberculosis = nn.Linear(64, 1)  # Binary classification (Tuberculosis)\n",
+        "        self.fc_lung_cancer = nn.Linear(64, 4)  # Multi-class output (Lung Cancer)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        # Extracting DenseNet features\n",
+        "        x = self.densenet.features(x)  # Extracting DenseNet feature maps\n",
+        "        x = self.conv_reduce(x)  # Reducing the number of feature channels\n",
+        "\n",
+        "        # Passing through simplified ViT module\n",
+        "        x = self.vit(x)\n",
+        "\n",
+        "        # Applying Global Average Pooling (GAP)\n",
+        "        x = x.mean(dim=[2, 3])  # Pooling across spatial dimensions\n",
+        "\n",
+        "        # Task-specific classification\n",
+        "        pneumonia_output = torch.sigmoid(self.fc_pneumonia(x))  # Binary sigmoid output\n",
+        "        tuberculosis_output = torch.sigmoid(self.fc_tuberculosis(x))  # Binary sigmoid output\n",
+        "        lung_cancer_output = self.fc_lung_cancer(x)  # Multi-class logits\n",
+        "\n",
+        "        return pneumonia_output, tuberculosis_output, lung_cancer_output"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "P4vHdzkA52Oe",
+        "outputId": "c10c4f4a-e6d9-4e3c-d34a-4dc53a306c66"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "e:\\anaconda3\\envs\\CVIP_ENV\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+            "  warnings.warn(\n",
+            "e:\\anaconda3\\envs\\CVIP_ENV\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=None`.\n",
+            "  warnings.warn(msg)\n",
+            "C:\\Users\\dpsvn\\AppData\\Local\\Temp\\ipykernel_31420\\2949034845.py:8: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+            "  model.load_state_dict(torch.load(\"CVIP_PROJ_model_FINAL.pth\", map_location=device))  # Mapping to the correct device\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "LightweightHybridDenseNetViT(\n",
+              "  (densenet): DenseNet(\n",
+              "    (features): Sequential(\n",
+              "      (conv0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+              "      (norm0): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "      (relu0): ReLU(inplace=True)\n",
+              "      (pool0): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+              "      (denseblock1): _DenseBlock(\n",
+              "        (denselayer1): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer2): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(96, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer3): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer4): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer5): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer6): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "      )\n",
+              "      (transition1): _Transition(\n",
+              "        (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "        (relu): ReLU(inplace=True)\n",
+              "        (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "        (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+              "      )\n",
+              "      (denseblock2): _DenseBlock(\n",
+              "        (denselayer1): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer2): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer3): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer4): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer5): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer6): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer7): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer8): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer9): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer10): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer11): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer12): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "      )\n",
+              "      (transition2): _Transition(\n",
+              "        (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "        (relu): ReLU(inplace=True)\n",
+              "        (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "        (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+              "      )\n",
+              "      (denseblock3): _DenseBlock(\n",
+              "        (denselayer1): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer2): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer3): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer4): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer5): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer6): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer7): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer8): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer9): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer10): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer11): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer12): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer13): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer14): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer15): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer16): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer17): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer18): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer19): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer20): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer21): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer22): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer23): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer24): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "      )\n",
+              "      (transition3): _Transition(\n",
+              "        (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "        (relu): ReLU(inplace=True)\n",
+              "        (conv): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "        (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+              "      )\n",
+              "      (denseblock4): _DenseBlock(\n",
+              "        (denselayer1): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer2): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer3): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer4): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer5): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer6): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer7): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer8): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer9): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer10): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer11): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer12): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer13): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer14): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer15): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "        (denselayer16): _DenseLayer(\n",
+              "          (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu1): ReLU(inplace=True)\n",
+              "          (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+              "          (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "          (relu2): ReLU(inplace=True)\n",
+              "          (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+              "        )\n",
+              "      )\n",
+              "      (norm5): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+              "    )\n",
+              "    (classifier): Linear(in_features=1024, out_features=1000, bias=True)\n",
+              "  )\n",
+              "  (conv_reduce): Conv2d(1024, 64, kernel_size=(1, 1), stride=(1, 1))\n",
+              "  (vit): SimpleViT(\n",
+              "    (transformer_blocks): ModuleList(\n",
+              "      (0): TransformerEncoderLayer(\n",
+              "        (self_attn): MultiheadAttention(\n",
+              "          (out_proj): NonDynamicallyQuantizableLinear(in_features=64, out_features=64, bias=True)\n",
+              "        )\n",
+              "        (linear1): Linear(in_features=64, out_features=128, bias=True)\n",
+              "        (dropout): Dropout(p=0.1, inplace=False)\n",
+              "        (linear2): Linear(in_features=128, out_features=64, bias=True)\n",
+              "        (norm1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
+              "        (norm2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
+              "        (dropout1): Dropout(p=0.1, inplace=False)\n",
+              "        (dropout2): Dropout(p=0.1, inplace=False)\n",
+              "      )\n",
+              "    )\n",
+              "  )\n",
+              "  (fc_pneumonia): Linear(in_features=64, out_features=1, bias=True)\n",
+              "  (fc_tuberculosis): Linear(in_features=64, out_features=1, bias=True)\n",
+              "  (fc_lung_cancer): Linear(in_features=64, out_features=4, bias=True)\n",
+              ")"
+            ]
+          },
+          "execution_count": 7,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Loading the saved model\n",
+        "img_size = 224  # Matching the dimensions used during training\n",
+        "patch_size = 8\n",
+        "\n",
+        "\n",
+        "model = LightweightHybridDenseNetViT().to(device)\n",
+        "\n",
+        "model.load_state_dict(torch.load(\"model_FINAL.pth\", map_location=device))  # Mapping to the correct device\n",
+        "model.to(device)  # Moving the model to GPU/CPU\n",
+        "model.eval()  # Setting to evaluation mode"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "55xG6fIf-Juc"
+      },
+      "source": [
+        "<br>\n",
+        "<br>\n",
+        "\n",
+        "### <b>STEP - 4 : Preprocessing the Image and Moving to GPU</b>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "id": "gBSz6oqF-KpK"
+      },
+      "outputs": [],
+      "source": [
+        "image_tensor = preprocess_single_image(\"Deploy-Test Images/642x361_SLIDE_4_What_Does_Lung_Cancer_Look_Like.jpg\")  # Path to the random image\n",
+        "image_tensor = image_tensor.to(device)  # Moving the input tensor to the same device"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Xqcipj_lDUFk"
+      },
+      "source": [
+        "<br>\n",
+        "<br>\n",
+        "\n",
+        "### <b>STEP - 5 : Performing Inference on GPU</b>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "CYfM_IZRDOSJ",
+        "outputId": "bc1ff79f-200c-4938-ddae-113316912060"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Pneumonia Probability: 0.9692\n",
+            "TB Probability: 0.8210\n",
+            "Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0384\n",
+            "    large.cell.carcinoma_left.hilum: 0.0717\n",
+            "    NORMAL: 0.7883\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.1015\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Performing inference\n",
+        "with torch.no_grad():\n",
+        "    pneumonia_output, tb_output, lung_cancer_output = model(image_tensor)\n",
+        "\n",
+        "# Converting outputs to probabilities\n",
+        "pneumonia_prob = pneumonia_output.item()  # Sigmoid ensures output in [0, 1]\n",
+        "tb_prob = tb_output.item()\n",
+        "lung_cancer_probs = F.softmax(lung_cancer_output, dim=1).squeeze().tolist()\n",
+        "\n",
+        "# Class names for lung cancer\n",
+        "lung_cancer_classes = [\n",
+        "    \"adenocarcinoma_left.lower.lobe\",\n",
+        "    \"large.cell.carcinoma_left.hilum\",\n",
+        "    \"NORMAL\",\n",
+        "    \"squamous.cell.carcinoma_left.hilum\"\n",
+        "]\n",
+        "\n",
+        "# Printing results\n",
+        "print(f\"Pneumonia Probability: {pneumonia_prob:.4f}\")\n",
+        "print(f\"TB Probability: {tb_prob:.4f}\")\n",
+        "\n",
+        "# Printing lung cancer probabilities with class names\n",
+        "print(\"Lung Cancer Probabilities:\")\n",
+        "for class_name, prob in zip(lung_cancer_classes, lung_cancer_probs):\n",
+        "    print(f\"    {class_name}: {prob:.4f}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "O99Sb29nEI9y"
+      },
+      "source": [
+        "<br>\n",
+        "<br>\n",
+        "\n",
+        "### <b>STEP - 6 : Taking a directory of images into consideration</b>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "id": "vjKToO-WDcDj"
+      },
+      "outputs": [],
+      "source": [
+        "# Directory containing the test images\n",
+        "\n",
+        "image_folder = \"Deploy-Test Images\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ee6Ct_z3ETpS",
+        "outputId": "18727f97-3ee7-4f66-8678-95ff1aed58a4"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "Image: 4994014ef5c834e4803541aa1dc874_big_gallery.jpg\n",
+            "  Pneumonia Probability: 0.9534\n",
+            "  TB Probability: 0.9138\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0689\n",
+            "    large.cell.carcinoma_left.hilum: 0.1746\n",
+            "    NORMAL: 0.4685\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.2880\n",
+            "\n",
+            "Image: 4ceeb362df213ccf2c0b4d6388bba1_gallery.jpg\n",
+            "  Pneumonia Probability: 0.9514\n",
+            "  TB Probability: 0.7690\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0709\n",
+            "    large.cell.carcinoma_left.hilum: 0.1399\n",
+            "    NORMAL: 0.5900\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.1993\n",
+            "\n",
+            "Image: 642x361_SLIDE_4_What_Does_Lung_Cancer_Look_Like.jpg\n",
+            "  Pneumonia Probability: 0.9692\n",
+            "  TB Probability: 0.8210\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0384\n",
+            "    large.cell.carcinoma_left.hilum: 0.0717\n",
+            "    NORMAL: 0.7883\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.1015\n",
+            "\n",
+            "Image: Chest_radiograph_of_miliary_tuberculosis_2.jpg\n",
+            "  Pneumonia Probability: 0.9638\n",
+            "  TB Probability: 0.0253\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.2013\n",
+            "    large.cell.carcinoma_left.hilum: 0.3206\n",
+            "    NORMAL: 0.1717\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.3064\n",
+            "\n",
+            "Image: Dense_opacity_of_primary_pulmonary_tuberculosis.jpg\n",
+            "  Pneumonia Probability: 0.9611\n",
+            "  TB Probability: 0.5479\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.1466\n",
+            "    large.cell.carcinoma_left.hilum: 0.2521\n",
+            "    NORMAL: 0.1795\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.4219\n",
+            "\n",
+            "Image: eXtmE1V2XgsjZK2JolVQ5g_Border_of_left_atrium.jpg\n",
+            "  Pneumonia Probability: 0.3524\n",
+            "  TB Probability: 0.9830\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0413\n",
+            "    large.cell.carcinoma_left.hilum: 0.0669\n",
+            "    NORMAL: 0.8216\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.0702\n",
+            "\n",
+            "Image: iStock_22401848_MEDIUM-58262cb63df78c6f6adebb27.jpg\n",
+            "  Pneumonia Probability: 0.8128\n",
+            "  TB Probability: 0.9765\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0307\n",
+            "    large.cell.carcinoma_left.hilum: 0.0801\n",
+            "    NORMAL: 0.7960\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.0932\n",
+            "\n",
+            "Image: lung-scan-article-l.jpg\n",
+            "  Pneumonia Probability: 0.9594\n",
+            "  TB Probability: 0.5150\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0991\n",
+            "    large.cell.carcinoma_left.hilum: 0.1557\n",
+            "    NORMAL: 0.5415\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.2036\n",
+            "\n",
+            "Image: lungcancer.jpg\n",
+            "  Pneumonia Probability: 0.5294\n",
+            "  TB Probability: 0.6075\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0749\n",
+            "    large.cell.carcinoma_left.hilum: 0.0500\n",
+            "    NORMAL: 0.8214\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.0537\n",
+            "\n",
+            "Image: Normal_posteroanterior_(PA)_chest_radiograph_(X-ray).jpg\n",
+            "  Pneumonia Probability: 0.9510\n",
+            "  TB Probability: 0.4999\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0698\n",
+            "    large.cell.carcinoma_left.hilum: 0.1852\n",
+            "    NORMAL: 0.4874\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.2576\n",
+            "\n",
+            "Image: photo.jpg\n",
+            "  Pneumonia Probability: 0.5363\n",
+            "  TB Probability: 0.2967\n",
+            "  Lung Cancer Probabilities:\n",
+            "    adenocarcinoma_left.lower.lobe: 0.0169\n",
+            "    large.cell.carcinoma_left.hilum: 0.0072\n",
+            "    NORMAL: 0.9690\n",
+            "    squamous.cell.carcinoma_left.hilum: 0.0069\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Looping through the folder, preprocessing each image, and running inference\n",
+        "results = []\n",
+        "for image_name in os.listdir(image_folder):\n",
+        "    image_path = os.path.join(image_folder, image_name)\n",
+        "\n",
+        "    if not image_name.lower().endswith(('.png', '.jpg', '.jpeg')):  # Ensuring it's an image file\n",
+        "        continue\n",
+        "\n",
+        "    # Preprocessing the image\n",
+        "    image_tensor = preprocess_single_image(image_path)\n",
+        "    image_tensor = image_tensor.to(device)\n",
+        "\n",
+        "    # Performing inference\n",
+        "    with torch.no_grad():\n",
+        "        pneumonia_output, tb_output, lung_cancer_output = model(image_tensor)\n",
+        "\n",
+        "    # Converting outputs to probabilities\n",
+        "    pneumonia_prob = pneumonia_output.item()\n",
+        "    tb_prob = tb_output.item()\n",
+        "    lung_cancer_probs = F.softmax(lung_cancer_output, dim=1).squeeze().tolist()\n",
+        "\n",
+        "    # Appending the results for the current image\n",
+        "    results.append({\n",
+        "        \"image_name\": image_name,\n",
+        "        \"pneumonia_prob\": pneumonia_prob,\n",
+        "        \"tb_prob\": tb_prob,\n",
+        "        \"lung_cancer_probs\": lung_cancer_probs\n",
+        "    })\n",
+        "\n",
+        "    lung_cancer_classes = [\n",
+        "    \"adenocarcinoma_left.lower.lobe\",\n",
+        "    \"large.cell.carcinoma_left.hilum\",\n",
+        "    \"NORMAL\",\n",
+        "    \"squamous.cell.carcinoma_left.hilum\"\n",
+        "    ]\n",
+        "\n",
+        "    # Printing the results\n",
+        "    print(f\"\\nImage: {image_name}\")\n",
+        "    print(f\"  Pneumonia Probability: {pneumonia_prob:.4f}\")\n",
+        "    print(f\"  TB Probability: {tb_prob:.4f}\")\n",
+        "\n",
+        "    # Printing lung cancer probabilities with class names\n",
+        "    print(\"  Lung Cancer Probabilities:\")\n",
+        "    for class_name, prob in zip(lung_cancer_classes, lung_cancer_probs):\n",
+        "        print(f\"    {class_name}: {prob:.4f}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "TByqsA1pEkdf"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "AlooBonda",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.11.9"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

model_FINAL.pth

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

requirements.txt

@@ -0,0 +1,14 @@
+numpy
+pandas
+tensorflow
+torch
+opencv-python
+scikit-learn
+matplotlib
+seaborn
+pillow
+torchvision
+collection
+tqdm
+ipykernel
+gradio

run.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Defining the environment name
+env_name="Chest_Disease"
+
+# Activating the conda environment
+source $(conda info --base)/etc/profile.d/conda.sh
+conda activate "$env_name"
+if [ $? -ne 0 ]; then
+    echo "Error: Failed to activate the conda environment '$env_name'."
+    exit 1
+fi
+
+echo "Conda environment '$env_name' activated."
+
+# Running the Python script to launch Gradio
+python final_project_Gradio_App.py
+if [ $? -ne 0 ]; then
+    echo "Error: Failed to run the Python script."
+    exit 1
+fi
+
+echo "Gradio application is running."