Initial commit of Mode_D_Appr_G1 and Model_I_Appr_H1

.gitignore

@@ -0,0 +1,177 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be added to the global gitignore or merged into this project gitignore.  For a PyTorch
+#  research project template, see https://github.com/PyTorchLightning/deep-learning-project-template
+#  PyCharm: File | Settings | File Templates
+.idea/
+
+# VS Code
+.vscode/
+
+# Gradio temporary files
+gradio_cached_examples/
+flagged/
+
+# Model files (too large for git)
+*.pt
+*.pth
+*.bin
+*.safetensors
+
+# Temporary files
+*.tmp
+*.temp

README.md

@@ -1,13 +1,65 @@
----
-title: Pneumonia Detection
-emoji: 🔥
-colorFrom: pink
-colorTo: red
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-short_description: Space for Pneumonia Detection Capstone project from GL
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Transfer Learning Inference
+emoji: 🧪
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Transfer Learning Inference App
+
+A Gradio-based inference application for transfer learning models supporting multiple architectures (ResNet, DenseNet, Inception, EfficientNet).
+
+## Features
+
+- **Multi-Model Support**: Supports ResNet, DenseNet, Inception V3, and EfficientNet architectures
+- **Dynamic Model Loading**: Automatically detects and loads available models from HuggingFace Hub
+- **Interactive Interface**: User-friendly dropdowns for model and approach selection
+- **Image Classification**: Upload images and get top-K predictions
+- **Grad-CAM Visualization**: Optional attention heatmaps for model interpretability
+- **Professional Results**: Clean tabular display of predictions with confidence scores
+
+## Supported Architectures
+
+- ResNet (resnet18, resnet34, resnet50, resnet101, resnet152)
+- DenseNet (densenet121, densenet161, densenet169, densenet201)
+- Inception V3
+- EfficientNet (via timm library)
+
+## Model Configuration
+
+The app expects models to be available either:
+1. Uploaded as files in this repository under `models/` directory
+2. Referenced from HuggingFace Hub repositories (set via environment variables)
+
+## Environment Variables
+
+- `HF_TOKEN`: HuggingFace API token for private model access (optional)
+- `MODEL_REPO_ID`: HuggingFace repository ID containing model weights (optional)
+- `NUM_CLASSES`: Number of output classes (default: 2)
+
+## Usage
+
+1. Select a model from the dropdown
+2. Choose an approach/variant
+3. Upload an image (JPG, PNG, etc.)
+4. Optionally enable Grad-CAM visualization
+5. Click "Run Inference" to see results
+
+## Local Development
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## Model Format
+
+Models should be saved as PyTorch state dictionaries (.pt files) with filenames following the pattern:
+`Appr_{approach}_{architecture}.pt`
+
+Example: `Appr_A_resnet50.pt`, `Appr_B_densenet121.pt`

app.py

@@ -0,0 +1,570 @@
+"""Gradio Inference App for Transfer Learning Models - HuggingFace Spaces Version
+
+Features:
+- Auto-scan models directory or HuggingFace Hub for available models and approaches.
+- Dropdown selection of Model and Approach.
+- Dynamic architecture detection from filename (e.g., resnet50, densenet121, inception_v3, efficientnet_b0, resnet34).
+- Image upload and preprocessing (ImageNet normalization).
+- Top-K prediction display (configurable class labels).
+- Optional Grad-CAM visualization for interpretability.
+- Environment variable configuration for HuggingFace deployment.
+- Graceful error handling and clear user feedback.
+
+Environment Variables:
+- HF_TOKEN: HuggingFace API token for private repositories
+- MODEL_REPO_ID: HuggingFace repository containing models
+- NUM_CLASSES: Number of output classes (default: 2)
+- DEBUG: Enable debug logging
+"""
+import os
+import re
+import logging
+from typing import Dict, Tuple, List, Optional, Union
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+from torchvision import models, transforms
+from PIL import Image
+import gradio as gr
+from huggingface_hub import hf_hub_download, list_repo_files
+from dotenv import load_dotenv
+
+try:
+    import timm  # EfficientNet etc.
+except ImportError:
+    timm = None
+
+try:
+    import cv2
+except ImportError:
+    cv2 = None
+
+# Load environment variables
+load_dotenv()
+
+# Configuration from environment variables
+HF_TOKEN = os.getenv("HF_TOKEN")
+MODEL_REPO_ID = os.getenv("MODEL_REPO_ID")
+NUM_CLASSES = int(os.getenv("NUM_CLASSES", "2"))
+DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+
+# Setup logging
+logging.basicConfig(level=logging.DEBUG if DEBUG else logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Directory paths
+MODELS_DIR = Path("models")
+MODELS_DIR.mkdir(exist_ok=True)
+
+# Placeholder class labels; customize based on your dataset
+CLASS_LABELS = {i: f"Class_{i}" for i in range(NUM_CLASSES)}
+
+# Architecture-specific input sizes
+_ARCH_INPUT_SIZE = {
+    "inception_v3": 299,
+    # Most others default to 224
+}
+
+# Regex to parse weight filenames: Appr_<Approach>_<arch>.pt
+WEIGHT_PATTERN = re.compile(r"Appr_([A-Za-z0-9]+)_([A-Za-z0-9_]+)\.pt")
+
+ModelMap = Dict[str, Dict[str, Dict[str, str]]]
+_model_map_cache: Optional[ModelMap] = None
+# Cache for instantiated models to avoid recreation per inference
+_model_instance_cache: Dict[Tuple[str, str], Tuple[torch.nn.Module, str]] = {}
+
+
+def download_models_from_hub() -> None:
+    """Download models from HuggingFace Hub if MODEL_REPO_ID is set."""
+    if not MODEL_REPO_ID:
+        logger.info("No MODEL_REPO_ID set, skipping Hub download")
+        return
+    
+    try:
+        logger.info(f"Downloading models from {MODEL_REPO_ID}")
+        repo_files = list_repo_files(MODEL_REPO_ID, token=HF_TOKEN)
+        model_files = [f for f in repo_files if f.endswith('.pt')]
+        
+        for model_file in model_files:
+            local_path = MODELS_DIR / model_file
+            if not local_path.exists():
+                logger.info(f"Downloading {model_file}")
+                downloaded_path = hf_hub_download(
+                    MODEL_REPO_ID,
+                    model_file,
+                    cache_dir=str(MODELS_DIR),
+                    token=HF_TOKEN
+                )
+                # Move to our models directory structure
+                local_path.parent.mkdir(parents=True, exist_ok=True)
+                Path(downloaded_path).rename(local_path)
+                
+    except Exception as e:
+        logger.warning(f"Failed to download from Hub: {e}")
+
+
+def scan_local_models() -> ModelMap:
+    """Scan local models directory for available models."""
+    mapping: ModelMap = {}
+    
+    # First, try to download from Hub
+    download_models_from_hub()
+    
+    # Scan the models directory
+    if MODELS_DIR.exists():
+        for item in MODELS_DIR.iterdir():
+            if item.is_dir():
+                # Model directory structure: models/Model_X/Appr_Y_arch.pt
+                model_name = item.name
+                for model_file in item.glob("*.pt"):
+                    match = WEIGHT_PATTERN.match(model_file.name)
+                    if match:
+                        appr_code, arch = match.groups()
+                        mapping.setdefault(model_name, {})[appr_code] = {
+                            "path": str(model_file),
+                            "arch": arch.lower(),
+                        }
+            elif item.suffix == ".pt":
+                # Flat structure: models/Appr_Y_arch.pt
+                match = WEIGHT_PATTERN.match(item.name)
+                if match:
+                    appr_code, arch = match.groups()
+                    model_name = f"Model_{arch}"
+                    mapping.setdefault(model_name, {})[appr_code] = {
+                        "path": str(item),
+                        "arch": arch.lower(),
+                    }
+    
+    return mapping
+
+
+def scan_weights(refresh: bool = False) -> ModelMap:
+    """Scan for available models, with caching."""
+    global _model_map_cache
+    if _model_map_cache is not None and not refresh:
+        return _model_map_cache
+    
+    mapping = scan_local_models()
+    
+    # Fallback: create demo models if none found
+    if not mapping:
+        logger.warning("No models found, creating demo entries")
+        mapping = {
+            "ResNet34": {
+                "G1": {"path": "", "arch": "resnet34"},
+            },
+            "InceptionV3": {
+                "H1": {"path": "", "arch": "inception_v3"},
+            }
+        }
+    
+    _model_map_cache = mapping
+    logger.info(f"Found models: {list(mapping.keys())}")
+    return mapping
+
+
+def _create_model(arch: str, num_classes: int) -> torch.nn.Module:
+    """Instantiate a model given architecture string."""
+    arch = arch.lower()
+    logger.debug(f"Creating model: {arch} with {num_classes} classes")
+    
+    if arch.startswith("resnet"):
+        base = getattr(models, arch)(weights=None)
+        base.fc = torch.nn.Linear(base.fc.in_features, num_classes)
+        return base
+    elif arch.startswith("densenet"):
+        base = getattr(models, arch)(weights=None)
+        base.classifier = torch.nn.Linear(base.classifier.in_features, num_classes)
+        return base
+    elif arch.startswith("inception_v3"):
+        # Disable aux logits for lighter inference path
+        base = models.inception_v3(weights=None, aux_logits=False)
+        base.fc = torch.nn.Linear(base.fc.in_features, num_classes)
+        return base
+    elif arch.startswith("efficientnet"):
+        if timm is None:
+            raise RuntimeError("timm not installed; cannot create EfficientNet model.")
+        base = timm.create_model(arch, pretrained=False, num_classes=num_classes)
+        return base
+    
+    # Fallback using timm if available
+    if timm is not None:
+        try:
+            return timm.create_model(arch, pretrained=False, num_classes=num_classes)
+        except Exception as e:
+            logger.warning(f"timm failed to create {arch}: {e}")
+    
+    raise ValueError(f"Unsupported architecture: {arch}")
+
+
+def _resolve_device() -> torch.device:
+    """Resolve device based on DEVICE env var (cpu|cuda|auto)."""
+    device_pref = os.getenv("DEVICE", "auto").lower()
+    if device_pref == "cpu":
+        return torch.device("cpu")
+    if device_pref == "cuda":
+        if torch.cuda.is_available():
+            return torch.device("cuda")
+        logger.warning("DEVICE=cuda requested but CUDA not available; falling back to CPU")
+        return torch.device("cpu")
+    # auto
+    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+def load_model(model_name: str, approach: str, use_cache: bool = True) -> Tuple[torch.nn.Module, str]:
+    """Load a model given model name and approach, optionally using cache."""
+    if use_cache:
+        cache_key = (model_name, approach)
+        if cache_key in _model_instance_cache:
+            return _model_instance_cache[cache_key]
+
+    mapping = scan_weights()
+    if model_name not in mapping:
+        raise ValueError(f"Model '{model_name}' not found in {list(mapping.keys())}")
+    if approach not in mapping[model_name]:
+        raise ValueError(
+            f"Approach '{approach}' not found for model '{model_name}'. Available: {list(mapping[model_name].keys())}"
+        )
+
+    info = mapping[model_name][approach]
+    arch = info["arch"]
+    weight_path = info["path"]
+
+    device = _resolve_device()
+    logger.info(f"Loading {model_name}/{approach} ({arch}) on {device}")
+
+    model = _create_model(arch, NUM_CLASSES)
+
+    # Load weights if path exists
+    if weight_path and Path(weight_path).exists():
+        try:
+            state = torch.load(weight_path, map_location=device)
+            if isinstance(state, dict) and "state_dict" in state:
+                state = state["state_dict"]
+
+            # Remove any DistributedDataParallel prefixes
+            new_state = {k.replace("module.", ""): v for k, v in state.items()}
+
+            missing, unexpected = model.load_state_dict(new_state, strict=False)
+            if missing:
+                logger.warning(f"Missing keys: {missing[:5]}...")
+            if unexpected:
+                logger.warning(f"Unexpected keys: {unexpected[:5]}...")
+
+        except Exception as e:
+            logger.warning(f"Failed to load weights from {weight_path}: {e}")
+    else:
+        logger.warning(f"No weights file found at {weight_path}, using random weights")
+
+    model.to(device)
+    model.eval()
+
+    if use_cache:
+        _model_instance_cache[cache_key] = (model, arch)
+
+    return model, arch
+
+
+_image_cache_transform: Dict[int, transforms.Compose] = {}
+
+
+def get_transform(arch: str) -> transforms.Compose:
+    """Get image transforms for the given architecture."""
+    size = _ARCH_INPUT_SIZE.get(arch, 224)
+    if size in _image_cache_transform:
+        return _image_cache_transform[size]
+    
+    t = transforms.Compose([
+        transforms.Resize((size, size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+    _image_cache_transform[size] = t
+    return t
+
+
+# Grad-CAM utilities
+class GradCAM:
+    """Grad-CAM implementation for generating attention heatmaps."""
+    
+    def __init__(self, model: torch.nn.Module, target_layer: Optional[str] = None):
+        self.model = model
+        self.model.eval()
+        self.target_layer = target_layer
+        self.activations = None
+        self.gradients = None
+        
+        # Try to automatically pick a layer if not provided
+        if target_layer is None:
+            layer = None
+            # Common patterns for different architectures
+            layer_candidates = ["layer4", "features.denseblock4", "blocks.6", "conv_head", "features"]
+            for cand in layer_candidates:
+                parts = cand.split('.')
+                current = model
+                try:
+                    for part in parts:
+                        current = getattr(current, part)
+                    layer = current
+                    break
+                except AttributeError:
+                    continue
+            self.target_module = layer if layer is not None else model
+        else:
+            self.target_module = dict(model.named_modules()).get(target_layer, model)
+        
+        def fwd_hook(_, __, output):
+            self.activations = output.detach()
+        
+        def bwd_hook(_, grad_input, grad_output):
+            if grad_output[0] is not None:
+                self.gradients = grad_output[0].detach()
+        
+        self.target_module.register_forward_hook(fwd_hook)
+        # Use full backward hook (non-deprecated) for gradient capture
+        try:
+            self.target_module.register_full_backward_hook(bwd_hook)
+        except AttributeError:
+            # Fallback if running older torch without full hook
+            self.target_module.register_backward_hook(bwd_hook)
+
+    def generate(self, tensor: torch.Tensor, class_idx: Optional[int] = None) -> torch.Tensor:
+        """Generate Grad-CAM heatmap."""
+        tensor = tensor.requires_grad_(True)
+        logits = self.model(tensor)
+        if isinstance(logits, tuple):  # Inception may return (logits, aux)
+            logits = logits[0]
+        
+        if class_idx is None:
+            class_idx = logits.argmax(dim=1).item()
+        
+        score = logits[:, class_idx]
+        score.backward(retain_graph=True)
+        
+        # Compute weights
+        grads = self.gradients  # [B, C, H, W]
+        acts = self.activations
+        
+        if grads is None or acts is None:
+            raise RuntimeError("GradCAM hooks did not capture activations/gradients")
+        
+        weights = grads.mean(dim=(2, 3), keepdim=True)  # [B, C, 1, 1]
+        cam = (weights * acts).sum(dim=1, keepdim=True)
+        cam = F.relu(cam)
+        cam = F.interpolate(cam, size=tensor.shape[2:], mode="bilinear", align_corners=False)
+        
+        # Normalize
+        cam_min, cam_max = cam.min(), cam.max()
+        cam = (cam - cam_min) / (cam_max - cam_min + 1e-8)
+        return cam.squeeze(0).squeeze(0)  # [H, W]
+
+
+def predict(image: Image.Image, model_name: str, approach: str, grad_cam: bool = False, top_k: int = 5):
+    """Run inference on the uploaded image."""
+    if image is None:
+        return [], None, None
+    
+    try:
+        model, arch = load_model(model_name, approach, use_cache=True)
+    except Exception as e:
+        logger.error(f"Model loading failed: {e}")
+        error_df = [["Error", 0.0, str(e)]]
+        return error_df, image, None
+    
+    try:
+        transform = get_transform(arch)
+        tensor = transform(image).unsqueeze(0)
+        device = next(model.parameters()).device
+        tensor = tensor.to(device)
+        
+        with torch.no_grad():
+            out = model(tensor)
+            if isinstance(out, tuple):  # Inception
+                out = out[0]
+            probs = F.softmax(out, dim=1).cpu().squeeze(0)
+        
+        top_k = min(top_k, probs.shape[0])
+        top_probs, top_indices = torch.topk(probs, top_k)
+        
+        results = []
+        for p, idx in zip(top_probs.tolist(), top_indices.tolist()):
+            label = CLASS_LABELS.get(idx, f"Class_{idx}")
+            results.append([label, round(p, 4)])
+        
+        cam_img = None
+        if grad_cam:
+            try:
+                gcam = GradCAM(model)
+                cam = gcam.generate(tensor)
+                
+                # Convert cam to PIL heatmap overlay
+                if cv2 is not None:
+                    import numpy as np
+                    base_img = image.resize((cam.shape[1], cam.shape[0]))
+                    base_arr = np.array(base_img)
+                    heatmap = (cam.cpu().numpy() * 255).astype('uint8')
+                    heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+                    heatmap = cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB)
+                    overlay = (0.4 * heatmap + 0.6 * base_arr).astype('uint8')
+                    cam_img = Image.fromarray(overlay)
+                else:
+                    # Fallback without OpenCV
+                    import numpy as np
+                    cam_np = cam.cpu().numpy()
+                    cam_img = Image.fromarray((cam_np * 255).astype('uint8'))
+                    
+            except Exception as e:
+                logger.warning(f"Grad-CAM failed: {e}")
+                cam_img = Image.new('RGB', (224, 224), color=(255, 100, 100))
+        
+        return results, image, cam_img
+    
+    except Exception as e:
+        logger.error(f"Prediction failed: {e}")
+        error_df = [["Error", 0.0, str(e)]]
+        return error_df, image, None
+
+
+def build_interface():
+    """Build the Gradio interface."""
+    mapping = scan_weights()
+    model_choices = sorted(mapping.keys())
+    
+    with gr.Blocks(
+        title="Transfer Learning Inference",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 1200px;
+            margin: auto;
+        }
+        """
+    ) as demo:
+        gr.Markdown(
+            """
+            # 🧪 Transfer Learning Inference
+            
+            Select a pre-trained model and approach, upload an image, and view predictions with optional attention visualization.
+            
+            **Available Models:** ResNet, DenseNet, Inception V3, EfficientNet
+            """
+        )
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                model_dd = gr.Dropdown(
+                    choices=model_choices,
+                    label="Model",
+                    value=model_choices[0] if model_choices else None,
+                    info="Select the model architecture"
+                )
+                approach_dd = gr.Dropdown(
+                    choices=[],
+                    label="Approach",
+                    info="Select the training approach/variant"
+                )
+                grad_cam_cb = gr.Checkbox(
+                    label="Generate Grad-CAM",
+                    value=False,
+                    info="Show attention heatmap overlay"
+                )
+                
+            with gr.Column(scale=2):
+                image_in = gr.Image(
+                    type="pil",
+                    label="Input Image",
+                    info="Upload an image for classification"
+                )
+        
+        submit_btn = gr.Button("🚀 Run Inference", variant="primary", size="lg")
+        
+        with gr.Row():
+            with gr.Column():
+                results_out = gr.Dataframe(
+                    headers=["Label", "Probability"],
+                    datatype=["str", "number"],
+                    label="🎯 Top Predictions",
+                    interactive=False
+                )
+            
+            with gr.Column():
+                with gr.Row():
+                    original_out = gr.Image(label="📷 Original Image", interactive=False)
+                    cam_out = gr.Image(label="🔥 Grad-CAM Overlay", interactive=False)
+        
+        # Add model info
+        with gr.Accordion("ℹ️ Model Information", open=False):
+            gr.Markdown(f"""
+            - **Number of Classes:** {NUM_CLASSES}
+            - **Available Models:** {len(model_choices)}
+            - **Environment:** {'HuggingFace Spaces' if MODEL_REPO_ID else 'Local'}
+            """)
+
+        def update_approaches(selected_model):
+            if not selected_model:
+                return gr.update(choices=[], value=None)
+            mapping_local = scan_weights()
+            apprs = sorted(mapping_local.get(selected_model, {}).keys())
+            value = apprs[0] if apprs else None
+            return gr.update(choices=apprs, value=value)
+
+        model_dd.change(fn=update_approaches, inputs=model_dd, outputs=approach_dd)
+
+        submit_btn.click(
+            fn=predict,
+            inputs=[image_in, model_dd, approach_dd, grad_cam_cb],
+            outputs=[results_out, original_out, cam_out],
+        )
+        
+        # Initialize approaches for first model
+        if model_choices:
+            demo.load(
+                fn=lambda: update_approaches(model_choices[0]),
+                inputs=None,
+                outputs=approach_dd
+            )
+    
+    return demo
+
+
+def main():
+    """Main function to launch the Gradio app."""
+    logger.info("Starting Transfer Learning Inference App")
+    demo = build_interface()
+    
+    # Configuration for different environments
+    server_name = os.getenv("GRADIO_SERVER_NAME", "0.0.0.0")
+    server_port = int(os.getenv("GRADIO_SERVER_PORT", "7860"))
+    share = os.getenv("GRADIO_SHARE", "False").lower() == "true"
+    
+    demo.launch(
+        server_name=server_name,
+        server_port=server_port,
+        share=share,
+        show_error=True
+    )
+
+
+if __name__ == "__main__":
+    # Quick internal test if requested
+    if os.environ.get("HEADLESS_TEST") == "1":
+        logger.info("Running headless test")
+        mapping = scan_weights()
+        if mapping:
+            first_model = next(iter(mapping))
+            first_appr = next(iter(mapping[first_model]))
+            try:
+                model, arch = load_model(first_model, first_appr)
+                size = _ARCH_INPUT_SIZE.get(arch, 224)
+                x = torch.randn(1, 3, size, size)
+                out = model(x)
+                if isinstance(out, tuple):
+                    out = out[0]
+                logger.info(f"Test forward output shape: {out.shape}")
+            except Exception as e:
+                logger.error(f"Test failed: {e}")
+        else:
+            logger.warning("No models found for testing")
+    else:
+        main()

requirements.txt

@@ -0,0 +1,10 @@
+torch==2.2.1
+torchvision==0.17.1
+timm==0.9.12
+gradio==4.44.0
+Pillow==10.4.0
+opencv-python-headless==4.9.0.80
+numpy==1.26.4
+huggingface-hub==0.23.4
+python-dotenv==1.0.1
+requests==2.32.3