Upload 5 files

.gitattributes

@@ -1,35 +1,23 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.md text eol=lf
+*.py text eol=lf
+*.txt text eol=lf
+*.json text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf
+
+# Model files
+*.pth binary
+*.bin binary
+*.pkl binary
+*.h5 binary
+
+# Images
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+
+# Archives
+*.zip binary
+*.tar.gz binary
+*.tgz binary

.gitignore

@@ -0,0 +1,39 @@
+# Model files (not needed for Spaces deployment - loaded from Hub)
+model/
+*.pth
+*.bin
+*.pkl
+*.h5
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environment files
+.env
+.venv
+env/
+venv/
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.temp

README_SPACES.md

@@ -0,0 +1,119 @@
+---
+title: ConvNeXt CheXpert Classifier with GradCAM
+emoji: 🫁
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: "4.0.0"
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+# 🫁 ConvNeXt CheXpert Classifier with GradCAM
+
+A web-based chest X-ray analysis tool using ConvNeXt-Base with CBAM attention mechanism. This app provides multi-label classification of 14 thoracic pathologies with GradCAM visualization showing where the model focuses its attention.
+
+## ✨ Features
+
+- 🔍 **Multi-label Classification**: Detects 14 different chest conditions
+- 📊 **Confidence Filtering**: Only shows predictions above 60% confidence
+- 🎯 **GradCAM Visualization**: See exactly where the model is looking
+- 🖼️ **Interactive Interface**: Easy-to-use web interface via Gradio
+- 🏥 **Research Ready**: Optimized for medical imaging research
+
+## 📋 Supported Conditions
+
+| # | Pathology | # | Pathology |
+|---|---|---|---|
+| 1 | No Finding | 8 | Pneumonia |
+| 2 | Enlarged Cardiomediastinum | 9 | Atelectasis |
+| 3 | Cardiomegaly | 10 | Pneumothorax |
+| 4 | Lung Opacity | 11 | Pleural Effusion |
+| 5 | Lung Lesion | 12 | Pleural Other |
+| 6 | Edema | 13 | Fracture |
+| 7 | Consolidation | 14 | Support Devices |
+
+## 🚀 Quick Start
+
+1. **Upload**: Click "Upload Chest X-ray" and select a chest X-ray image
+2. **Analyze**: The model will process the image and show confident predictions
+3. **Review**: View GradCAM visualizations showing model attention regions
+
+## 📊 How It Works
+
+### Model Architecture
+- **Backbone**: ConvNeXt-Base (modern efficient architecture)
+- **Attention**: CBAM (Convolutional Block Attention Module)
+- **Input**: 384×384 chest X-rays (automatically resized)
+- **Output**: 14 pathology probabilities with sigmoid activation
+
+### GradCAM Visualization
+- **Heatmap**: Shows attention intensity (red = high attention)
+- **Overlay**: Superimposes attention map on original X-ray
+- **Confidence**: Only displays findings above 60% confidence threshold
+
+## 🏗️ Technical Details
+
+### Model Performance
+- **Validation AUC**: 0.81 (multi-label)
+- **Parameters**: ~88M + CBAM attention
+- **Training Data**: CheXpert dataset (224K+ chest X-rays)
+- **Framework**: PyTorch + timm library
+
+### Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+## ⚠️ Important Medical Disclaimer
+
+**🚨 FOR RESEARCH & EDUCATION ONLY 🚨**
+
+### ❌ DO NOT USE FOR:
+- Clinical diagnosis or treatment decisions
+- Emergency medical situations
+- Replacing professional radiologist review
+- Patient care without expert validation
+
+### ⚠️ Limitations:
+- Not clinically validated or FDA-approved
+- Trained on historical Stanford data (2002-2017)
+- Performance may vary on different populations/equipment
+- Requires qualified radiologist review for any clinical use
+
+### ✅ Appropriate Uses:
+- Academic research and benchmarking
+- Algorithm development and comparison
+- Educational demonstrations
+- Proof-of-concept prototypes
+
+**Always consult qualified healthcare professionals for medical decisions.**
+
+## 📚 Citation
+
+If you use this work in publications, please cite:
+
+```bibtex
+@software{convnext_chexpert_attention_2025,
+  author = {Time},
+  title = {ConvNeXt-Base CheXpert Classifier with CBAM Attention},
+  year = {2025},
+  publisher = {HuggingFace},
+  url = {https://huggingface.co/spaces/your-username/convnext-chexpert-gradcam}
+}
+```
+
+## 🔗 Links
+
+- **Original Repository**: [GitHub](https://github.com/jikaan/convnext-chexpert-attention)
+- **CheXpert Dataset**: [Stanford ML Group](https://stanfordmlgroup.github.io/competitions/chexpert/)
+- **Paper**: [CheXpert: A large chest radiograph dataset](https://arxiv.org/abs/1901.07031)
+
+## 📄 License
+
+Apache License 2.0 - See [LICENSE](https://github.com/jikaan/convnext-chexpert-attention/blob/main/LICENSE) for details.
+
+---
+
+**Created by Time | October 2025**

app.py

@@ -0,0 +1,326 @@
+"""
+HuggingFace Spaces App for ConvNeXt CheXpert Classification with GradCAM
+
+This app provides a web interface for chest X-ray classification with GradCAM visualization
+showing model attention regions for confident predictions (>60% confidence).
+
+Usage:
+    Run this file and access the Gradio interface via the provided URL
+"""
+
+import os
+import torch
+import timm
+import gradio as gr
+import numpy as np
+import torch.nn as nn
+import matplotlib.pyplot as plt
+from PIL import Image
+from torchvision import transforms
+import cv2
+
+# GradCAM imports
+try:
+    from pytorch_grad_cam import GradCAM
+    from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+    from pytorch_grad_cam.utils.image import show_cam_on_image
+except ImportError:
+    print("Installing required packages...")
+    os.system("pip install pytorch-grad-cam")
+
+# Disease labels in the correct order
+DISEASE_LABELS = [
+    "No Finding", "Enlarged Cardiomediastinum", "Cardiomegaly",
+    "Lung Opacity", "Lung Lesion", "Edema", "Consolidation",
+    "Pneumonia", "Atelectasis", "Pneumothorax", "Pleural Effusion",
+    "Pleural Other", "Fracture", "Support Devices"
+]
+
+# Model configuration
+MODEL_CONFIG = {
+    "input_size": 384,
+    "num_classes": 14,
+    "mean": [0.5029414296150208] * 3,
+    "std": [0.2892409563064575] * 3
+}
+
+class ConvNeXtWithCBAM(nn.Module):
+    """ConvNeXt model with CBAM attention for GradCAM compatibility"""
+    def __init__(self, num_classes=14, model_name="convnext_base"):
+        super().__init__()
+        # Create ConvNeXt backbone
+        self.backbone = timm.create_model(
+            model_name,
+            pretrained=False,
+            num_classes=0,
+            features_only=True
+        )
+
+        # Add CBAM attention
+        feature_dim = self.backbone.feature_info.channels()[-1]
+        self.cbam = self._create_cbam_attention(feature_dim)
+
+        # Global pooling and classifier
+        self.global_pool = nn.AdaptiveAvgPool2d(1)
+        self.classifier = nn.Linear(feature_dim, num_classes)
+
+    def _create_cbam_attention(self, channels, reduction=16, kernel_size=7):
+        """Create CBAM attention module"""
+        return nn.Sequential(
+            # Channel attention
+            nn.AdaptiveAvgPool2d(1),
+            nn.Conv2d(channels, channels // reduction, 1, bias=False),
+            nn.ReLU(),
+            nn.Conv2d(channels // reduction, channels, 1, bias=False),
+            nn.Sigmoid(),
+            # Spatial attention
+            nn.Conv2d(2, 1, kernel_size, padding=kernel_size // 2, bias=False),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        # Extract features
+        features = self.backbone(x)[-1]
+
+        # Apply CBAM attention
+        ca = self.cbam[:5](features)  # Channel attention
+        features = features * ca
+
+        # Spatial attention (simplified for GradCAM)
+        avg_out = torch.mean(features, dim=1, keepdim=True)
+        max_out, _ = torch.max(features, dim=1, keepdim=True)
+        sa = self.cbam[5](torch.cat([avg_out, max_out], dim=1))
+        features = features * sa
+
+        # Global pooling and classification
+        features = self.global_pool(features)
+        features = features.view(features.size(0), -1)
+        return self.classifier(features)
+
+def load_model(model_repo="calender/Convnext-Chexpert-Attention"):
+    """Load the trained model from HuggingFace Hub"""
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+
+    # Create model
+    model = ConvNeXtWithCBAM(num_classes=14).to(device)
+
+    # Load state dict from HuggingFace Hub
+    try:
+        from huggingface_hub import hf_hub_download
+        model_path = hf_hub_download(repo_id=model_repo, filename="model.pth")
+        print(f"Downloaded model from {model_repo}")
+    except ImportError:
+        print("huggingface_hub not available, trying local model...")
+        model_path = "model/model.pth"
+
+    state_dict = torch.load(model_path, map_location=device)
+
+    # Handle DataParallel
+    if any(key.startswith('module.') for key in state_dict.keys()):
+        state_dict = {k.replace('module.', ''): v for k, v in state_dict.items()}
+
+    model.load_state_dict(state_dict)
+    model.eval()
+
+    print("Model loaded successfully!")
+    return model, device
+
+def predict_with_gradcam(model, device, image, confidence_threshold=0.6):
+    """Get predictions and GradCAM visualizations for confident predictions"""
+
+    # Image preprocessing
+    transform = transforms.Compose([
+        transforms.Grayscale(num_output_channels=3),  # Convert grayscale to RGB
+        transforms.Resize((MODEL_CONFIG["input_size"], MODEL_CONFIG["input_size"])),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=MODEL_CONFIG["mean"], std=MODEL_CONFIG["std"])
+    ])
+
+    # Prepare input
+    input_tensor = transform(image).unsqueeze(0).to(device)
+
+    # Get predictions
+    with torch.no_grad():
+        logits = model(input_tensor)
+        probabilities = torch.sigmoid(logits).squeeze().cpu().numpy()
+
+    # Find confident predictions
+    confident_indices = []
+    confident_predictions = []
+
+    for idx, (prob, disease) in enumerate(zip(probabilities, DISEASE_LABELS)):
+        if prob > confidence_threshold:
+            confident_indices.append(idx)
+            confident_predictions.append({
+                'disease': disease,
+                'confidence': float(prob),
+                'class_idx': idx
+            })
+
+    if not confident_predictions:
+        return {
+            'predictions': [],
+            'message': f'No findings above {confidence_threshold:.0%} confidence threshold',
+            'visualizations': None
+        }
+
+    # Find target layer for GradCAM
+    target_layer = None
+    for module in reversed(list(model.backbone.modules())):
+        if isinstance(module, nn.Conv2d):
+            target_layer = module
+            break
+
+    if target_layer is None:
+        return {
+            'predictions': confident_predictions,
+            'message': 'Could not find suitable layer for GradCAM',
+            'visualizations': None
+        }
+
+    # Generate GradCAM for each confident prediction
+    visualizations = {}
+
+    for pred in confident_predictions:
+        class_idx = pred['class_idx']
+        disease = pred['disease']
+        confidence = pred['confidence']
+
+        # Generate GradCAM
+        targets = [ClassifierOutputTarget(class_idx)]
+
+        try:
+            with GradCAM(model=model, target_layers=[target_layer]) as cam:
+                grayscale_cam = cam(input_tensor=input_tensor, targets=targets)[0, :]
+
+            # Convert to RGB for visualization
+            rgb_img = np.array(image.convert('RGB'), dtype=np.float32) / 255.0
+
+            # Resize heatmap to match image
+            grayscale_cam_resized = cv2.resize(grayscale_cam, (rgb_img.shape[1], rgb_img.shape[0]))
+
+            # Create overlay
+            cam_overlay = show_cam_on_image(
+                rgb_img,
+                grayscale_cam_resized,
+                use_rgb=True,
+                image_weight=0.5,
+                colormap=cv2.COLORMAP_JET
+            )
+
+            visualizations[disease] = {
+                'heatmap': grayscale_cam_resized,
+                'overlay': cam_overlay,
+                'confidence': confidence
+            }
+
+        except Exception as e:
+            print(f"Error generating GradCAM for {disease}: {e}")
+            continue
+
+    return {
+        'predictions': confident_predictions,
+        'message': f'Found {len(confident_predictions)} confident predictions above {confidence_threshold:.0%} threshold',
+        'visualizations': visualizations
+    }
+
+def create_gradio_interface():
+    """Create and configure the Gradio interface"""
+    model, device = load_model()
+
+    def analyze_xray(image):
+        """Analyze uploaded X-ray image"""
+        if image is None:
+            return "Please upload a chest X-ray image", None, None
+
+        try:
+            # Get predictions and GradCAM
+            results = predict_with_gradcam(model, device, image)
+
+            if not results['predictions']:
+                return results['message'], None, None
+
+            # Create prediction text
+            prediction_text = f"## Analysis Results\n\n{results['message']}\n\n"
+            prediction_text += "### Confident Predictions:\n\n"
+
+            for pred in results['predictions']:
+                prediction_text += f"🔍 **{pred['disease']}**: {pred['confidence']:.1%}\n"
+
+            # Create visualization plots
+            if results['visualizations']:
+                num_plots = len(results['visualizations'])
+                fig, axes = plt.subplots(num_plots, 3, figsize=(15, 5 * num_plots))
+
+                if num_plots == 1:
+                    axes = axes.reshape(1, -1)
+
+                for i, (disease, vis_data) in enumerate(results['visualizations'].items()):
+                    # Original image
+                    axes[i, 0].imshow(image, cmap='gray')
+                    axes[i, 0].set_title(f"Original X-ray\n{disease}", fontsize=10)
+                    axes[i, 0].axis('off')
+
+                    # GradCAM heatmap
+                    axes[i, 1].imshow(vis_data['heatmap'], cmap='jet')
+                    axes[i, 1].set_title(f"GradCAM Heatmap\n{vis_data['confidence']:.1%}", fontsize=10)
+                    axes[i, 1].axis('off')
+
+                    # GradCAM overlay
+                    axes[i, 2].imshow(vis_data['overlay'])
+                    axes[i, 2].set_title(f"GradCAM Overlay\n{disease}", fontsize=10)
+                    axes[i, 2].axis('off')
+
+                plt.tight_layout()
+
+                return prediction_text, fig, "✅ Analysis completed successfully!"
+
+            return prediction_text, None, "✅ Analysis completed successfully!"
+
+        except Exception as e:
+            return f"❌ Error analyzing image: {str(e)}", None, "Analysis failed"
+
+    # Create Gradio interface
+    interface = gr.Interface(
+        fn=analyze_xray,
+        inputs=gr.Image(label="Upload Chest X-ray", type="pil"),
+        outputs=[
+            gr.Markdown(label="Analysis Results"),
+            gr.Plot(label="GradCAM Visualizations"),
+            gr.Textbox(label="Status", interactive=False)
+        ],
+        title="🫁 ConvNeXt CheXpert Classifier with GradCAM",
+        description="""
+        **Medical AI for Chest X-ray Analysis**
+
+        This tool uses a ConvNeXt-Base model with CBAM attention to analyze chest X-rays and identify 14 different thoracic pathologies.
+
+        **Features:**
+        - 🔍 Multi-label classification of 14 chest conditions
+        - 📊 Shows only confident predictions (>60% confidence)
+        - 🎯 GradCAM visualization showing model attention regions
+        - 🏥 Designed for research and educational purposes
+
+        **⚠️ Important Medical Disclaimer:**
+        This tool is for research and educational purposes only. Always consult qualified healthcare professionals for medical decisions.
+
+        **Supported Conditions:**
+        No Finding, Enlarged Cardiomediastinum, Cardiomegaly, Lung Opacity, Lung Lesion, Edema, Consolidation, Pneumonia, Atelectasis, Pneumothorax, Pleural Effusion, Pleural Other, Fracture, Support Devices
+        """,
+        theme="default",
+        allow_flagging="never"
+    )
+
+    return interface
+
+# Main execution
+if __name__ == "__main__":
+    print("Starting ConvNeXt CheXpert GradCAM App...")
+    interface = create_gradio_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )

requirements.txt

@@ -0,0 +1,32 @@
+# Core dependencies for ConvNeXt CheXpert Classification with GradCAM
+torch>=2.0.0
+torchvision>=0.15.0
+torchaudio>=2.0.0
+
+# Computer vision and image processing
+timm>=0.9.0
+opencv-python>=4.8.0
+Pillow>=9.0.0
+numpy>=1.24.0
+
+# Data science and visualization
+scikit-learn>=1.3.0
+matplotlib>=3.7.0
+
+# HuggingFace ecosystem
+datasets>=2.10.0
+huggingface-hub>=0.15.0
+
+# Utilities
+tqdm>=4.65.0
+
+# Grad-CAM visualization
+pytorch-grad-cam>=1.2.0
+
+# HuggingFace Spaces web interface
+gradio>=4.0.0
+
+# Optional: Enhanced model training (if needed)
+ema-pytorch>=0.2.0
+
+