Remove unused files: old Gradio frontend, dead model code, test artifacts

- frontend/ — entire old Gradio UI, replaced by React
- models/explainability.py — old GradCAM, replaced by gradcam_tool.py
- models/medsiglip_convnext_fusion.py — abandoned experimental model
- models/monet_concepts.py — old concept scorer, replaced by monet_tool.py
- test_models.py — one-off test script
- KAGGLE_REPORT.md — temporary report file

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

KAGGLE_REPORT.md

@@ -1,104 +0,0 @@
-# SkinProAI: Explainable Multi-Model Dermatology Decision Support
-
-## 1. System Architecture & AI Pipeline
-
-SkinProAI is a clinician-first dermatology decision-support system that orchestrates multiple specialised AI models through a four-phase analysis pipeline. The system is designed to run entirely on-device using Google's MedGemma 4B — a 4-billion-parameter vision-language model purpose-built for edge deployment in clinical settings — executing on consumer hardware (Apple M4 Pro / MPS) in bfloat16 precision without requiring cloud GPU infrastructure.
-
-### 1.1 Multi-Model Orchestration via MCP
-
-Rather than relying on a single monolithic model, SkinProAI employs a Model Context Protocol (MCP) architecture that isolates each AI capability as an independent tool callable via JSON-RPC over subprocess stdio. This design provides fault isolation, independent model loading, and a clear audit trail of which model produced which output.
-
-| Tool | Model | Purpose |
-|------|-------|---------|
-| `monet_analyze` | MONET (contrastive vision-language) | Extract 7 dermoscopic concept scores: ulceration, hair structures, vascular patterns, erythema, pigmented structures, gel artefacts, skin markings |
-| `classify_lesion` | ConvNeXt Base + metadata MLP | 11-class lesion classification using dual-encoder architecture combining image features with MONET concept scores |
-| `generate_gradcam` | Grad-CAM on ConvNeXt | Generate visual attention heatmap overlays highlighting regions driving the classification decision |
-| `search_guidelines` | FAISS + all-MiniLM-L6-v2 | Retrieve relevant clinical guideline passages from a RAG index of 286 chunks across 7 dermatology PDFs |
-| `compare_images` | MONET + overlay | Temporal change detection comparing dermoscopic feature vectors between sequential images |
-
-All tools receive absolute file paths as input (never raw image data), enabling secure subprocess isolation between the main FastAPI process (Python 3.9) and the MCP server (Python 3.11).
-
-### 1.2 Four-Phase Analysis Pipeline
-
-Every image analysis follows a structured, transparent pipeline:
-
-**Phase 1 — Independent Visual Examination.** MedGemma 4B performs a systematic dermoscopic assessment *before* seeing any AI tool output. It evaluates pattern architecture, colour distribution, border characteristics, and structural features, producing differential diagnoses ranked by clinical probability. This deliberate sequencing prevents anchoring bias — the language model forms its own clinical impression independently.
-
-**Phase 2 — AI Classification Tools.** Three MCP tools execute in sequence: MONET extracts quantitative concept scores (0–1 range for each dermoscopic feature), ConvNeXt classifies the lesion into one of 11 diagnostic categories with calibrated probabilities, and Grad-CAM generates an attention overlay showing which image regions drove the classification. Each tool's output is streamed to the clinician in real-time with visual bar charts.
-
-**Phase 3 — Reconciliation.** MedGemma receives both its own Phase 1 assessment and the Phase 2 tool outputs, then performs explicit agreement/disagreement analysis. It identifies where its visual findings align with or diverge from the quantitative classifiers, produces an integrated assessment with a stated confidence level, and explains its reasoning. This adversarial cross-check between independent assessments is central to the system's reliability.
-
-**Phase 4 — Management Guidance with RAG.** The system automatically queries a FAISS-indexed knowledge base of clinical dermatology guidelines (BAD, NICE, and specialist PDFs covering BCC, SCC, melanoma, actinic keratosis, contact dermatitis, lichen sclerosus, and cutaneous warts). Using the diagnosed condition as a search query, the RAG system retrieves the top-5 most relevant guideline passages via cosine similarity over sentence-transformer embeddings (all-MiniLM-L6-v2, 384 dimensions). MedGemma then synthesises lesion-specific management recommendations — biopsy, excision, monitoring, or discharge — grounded in the retrieved evidence, with inline superscript citations linking back to source documents and page numbers.
-
----
-
-## 2. AI Explainability
-
-Explainability is not an afterthought in SkinProAI — it is embedded at every layer of the architecture. The system provides three complementary forms of explanation: visual, quantitative, and narrative.
-
-### 2.1 Visual Explainability: Grad-CAM Attention Maps
-
-Grad-CAM (Gradient-weighted Class Activation Mapping) hooks into the final convolutional layer of the ConvNeXt classifier to produce a spatial heatmap overlay on the original dermoscopic image. This directly answers the question "where is the model looking?" — showing clinicians which morphological features (border irregularity, colour variegation, structural asymmetry) are driving the classification. For temporal comparisons, the system generates side-by-side Grad-CAM pairs (previous vs. current) so clinicians can visually assess whether attention regions have shifted, expanded, or resolved.
-
-### 2.2 Quantitative Explainability: MONET Concept Scores
-
-MONET provides human-interpretable concept decomposition by scoring seven clinically meaningful dermoscopic features on a continuous 0–1 scale. Unlike black-box classifiers that output only a label and probability, MONET's concept scores reveal *why* a lesion received its classification: a high vascular score combined with low pigmentation explains a vascular lesion diagnosis; high pigmented-structure scores with border irregularity support melanocytic concern. These scores are rendered as visual bar charts in the streaming UI, giving clinicians immediate quantitative insight into the feature profile driving the AI's assessment.
-
-When comparing sequential images over time, the system computes MONET feature deltas — the signed difference in each concept score between timepoints — enabling objective quantification of lesion evolution. A change from 0.3 to 0.7 in the vascular score, for example, signals new vessel formation that warrants clinical attention, independent of any subjective visual comparison.
-
-### 2.3 Narrative Explainability: MedGemma Reasoning Transparency
-
-The streaming interface exposes MedGemma's reasoning process through structured markup segments. `[THINKING]` blocks display the model's intermediate reasoning (differential construction, feature weighting, agreement analysis) in real-time, with animated spinners that resolve to completion indicators as each reasoning phase finishes. `[RESPONSE]` blocks contain the synthesised clinical narrative. This staged transparency allows clinicians to follow the AI's analytical process rather than receiving only a final pronouncement.
-
-The reconciliation phase (Phase 3) is particularly significant for explainability: MedGemma explicitly states where its independent visual assessment agrees or disagrees with the quantitative classifiers, and explains the basis for its integrated conclusion. This adversarial structure makes disagreements visible and auditable.
-
-### 2.4 Evidence Grounding: RAG Citations
-
-Management recommendations in Phase 4 include inline superscript references (e.g., "Wide local excision with 2cm margins is recommended for tumours >2mm Breslow thickness¹") linked to specific guideline documents and page numbers. This evidence chain — from diagnosis through to management recommendation — is fully traceable to published clinical guidelines, supporting regulatory compliance and clinical governance requirements.
-
----
-
-## 3. Clinician-First Design & User Interface
-
-### 3.1 Design Philosophy
-
-SkinProAI is built around the principle that AI should augment clinical decision-making, not replace it. The interface is designed for the workflow of a clinician reviewing dermoscopic images: patient selection, lesion documentation, temporal tracking, and structured analysis with clear next-step guidance.
-
-The system deliberately avoids presenting AI conclusions as definitive diagnoses. Instead, results are framed as ranked differentials with calibrated confidence scores, supported by quantitative feature evidence and visual attention maps. The clinician retains full agency over the diagnostic and management decision.
-
-### 3.2 Streaming Real-Time Interface
-
-The UI employs Server-Sent Events (SSE) to stream analysis output in real-time, maintaining clinician engagement during model inference. Rather than a loading spinner followed by a wall of text, clinicians observe the analysis unfolding phase by phase:
-
-- **Tool status lines** appear as compact single-line indicators with animated spinners that resolve to green completion dots, showing tool name and summary result (e.g., "ConvNeXt classification — Melanoma (89%)")
-- **Thinking indicators** display MedGemma's reasoning steps with spinners that transition to done states as each phase completes
-- **Streamed text** appears word-by-word, allowing clinicians to begin reading findings before analysis completes
-
-This streaming pattern reduces perceived latency and provides transparency into the multi-model pipeline's progress.
-
-### 3.3 Temporal Lesion Tracking
-
-The data model supports longitudinal monitoring through a Patient → Lesion → LesionImage hierarchy. Each lesion maintains a timeline of images with timestamps, and the system automatically triggers temporal comparison when a new image is uploaded for a previously-analysed lesion. Comparison results include MONET feature deltas, side-by-side Grad-CAM overlays, and a status classification (Stable / Minor Change / Significant Change / Improved) rendered with colour-coded indicators.
-
-This temporal architecture supports the clinical workflow for monitoring suspicious lesions over time — a common scenario in dermatology where serial dermoscopy is preferred over immediate biopsy for lesions with intermediate risk profiles.
-
-### 3.4 Conversational Follow-Up
-
-After analysis completes, the system transitions to a conversational interface where clinicians can ask follow-up questions grounded in the analysis context. The chat maintains full awareness of the diagnosed condition, MONET features, classification results, and guideline context, enabling queries like "what are the excision margin recommendations for this depth?" or "how does the asymmetry score compare to the previous image?" The text-only chat pathway routes through MedGemma with the full analysis state, ensuring responses remain clinically contextualised.
-
-### 3.5 Edge Deployment Architecture
-
-SkinProAI runs entirely on-device using MedGemma 4B in bfloat16 precision on consumer hardware (demonstrated on Apple M4 Pro with 24GB RAM using Metal Performance Shaders). No patient data leaves the device — all inference, image storage, and guideline retrieval execute locally. This edge-first architecture addresses data sovereignty requirements in clinical settings where patient images cannot be transmitted to cloud services. The system also supports containerised deployment via Docker for institutional environments, with optional GPU acceleration on CUDA-equipped hardware or HuggingFace Spaces.
-
-### 3.6 Interface Components
-
-The frontend is built in React 18 with a glassmorphism-inspired design language. Key interface elements include:
-
-- **Patient grid** — Card-based patient selection with creation workflow
-- **Chat interface** — Unified conversation view combining image analysis, tool outputs, and text chat in a single scrollable thread
-- **Tool call cards** — Inline status indicators for each AI tool invocation (analyse, classify, Grad-CAM, guidelines search, compare) with expandable result summaries
-- **Image upload** — Drag-and-drop or click-to-upload with preview, supporting both initial analysis and temporal comparison workflows
-- **Post-analysis prompt** — Contextual hint guiding clinicians to ask follow-up questions, provide additional context, or upload comparison images
-- **Markdown rendering** — Clinical narratives rendered with proper formatting, headers, lists, and inline citations for readability
-
-The interface prioritises information density without clutter: tool outputs collapse to single-line summaries by default, reasoning phases are visually distinguished from conclusions, and temporal comparisons use colour-coded status indicators (green/amber/red/blue) that map to clinical urgency levels.

frontend/app.py

@@ -1,532 +0,0 @@
-"""
-SkinProAI Frontend - Modular Gradio application
-"""
-
-import gradio as gr
-from typing import Dict, Generator, Optional
-from datetime import datetime
-import sys
-import os
-import re
-import base64
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from data.case_store import get_case_store
-from frontend.components.styles import MAIN_CSS
-from frontend.components.analysis_view import format_output
-
-
-# =============================================================================
-# CONFIG
-# =============================================================================
-
-class Config:
-    APP_TITLE = "SkinProAI"
-    SERVER_PORT = int(os.environ.get("GRADIO_SERVER_PORT", "7860"))
-    HF_SPACES = os.environ.get("SPACE_ID") is not None
-
-
-# =============================================================================
-# AGENT
-# =============================================================================
-
-class AnalysisAgent:
-    """Wrapper for the MedGemma analysis agent"""
-
-    def __init__(self):
-        self.model = None
-        self.loaded = False
-
-    def load(self):
-        if self.loaded:
-            return
-        from models.medgemma_agent import MedGemmaAgent
-        self.model = MedGemmaAgent(verbose=True)
-        self.model.load_model()
-        self.loaded = True
-
-    def analyze(self, image_path: str, question: str = "") -> Generator[str, None, None]:
-        if not self.loaded:
-            yield "[STAGE:loading]Loading AI models...[/STAGE]\n"
-            self.load()
-
-        for chunk in self.model.analyze_image_stream(image_path, question=question):
-            yield chunk
-
-    def management_guidance(self, confirmed: bool, feedback: str = None) -> Generator[str, None, None]:
-        for chunk in self.model.generate_management_guidance(confirmed, feedback):
-            yield chunk
-
-    def followup(self, message: str) -> Generator[str, None, None]:
-        if not self.loaded or not self.model.last_diagnosis:
-            yield "[ERROR]No analysis context available.[/ERROR]\n"
-            return
-        for chunk in self.model.chat_followup(message):
-            yield chunk
-
-    def reset(self):
-        if self.model:
-            self.model.reset_state()
-
-
-agent = AnalysisAgent()
-case_store = get_case_store()
-
-
-# =============================================================================
-# APP
-# =============================================================================
-
-with gr.Blocks(title=Config.APP_TITLE, css=MAIN_CSS, theme=gr.themes.Soft()) as app:
-
-    # =========================================================================
-    # STATE
-    # =========================================================================
-    state = gr.State({
-        "page": "patient_select",  # patient_select | analysis
-        "case_id": None,
-        "instance_id": None,
-        "output": "",
-        "gradcam_base64": None
-    })
-
-    # =========================================================================
-    # PAGE 1: PATIENT SELECTION
-    # =========================================================================
-    with gr.Group(visible=True, elem_classes=["patient-select-container"]) as page_patient:
-        gr.Markdown("# SkinProAI", elem_classes=["patient-select-title"])
-        gr.Markdown("Select a patient to continue or create a new case", elem_classes=["patient-select-subtitle"])
-
-        with gr.Row(elem_classes=["patient-grid"]):
-            btn_demo_melanoma = gr.Button("Demo: Melanocytic Lesion", elem_classes=["patient-card"])
-            btn_demo_ak = gr.Button("Demo: Actinic Keratosis", elem_classes=["patient-card"])
-            btn_new_patient = gr.Button("+ New Patient", variant="primary", elem_classes=["new-patient-btn"])
-
-    # =========================================================================
-    # PAGE 2: ANALYSIS
-    # =========================================================================
-    with gr.Group(visible=False) as page_analysis:
-
-        # Header
-        with gr.Row(elem_classes=["app-header"]):
-            gr.Markdown(f"**{Config.APP_TITLE}**", elem_classes=["app-title"])
-            btn_back = gr.Button("< Back to Patients", elem_classes=["back-btn"])
-
-        with gr.Row(elem_classes=["analysis-container"]):
-
-            # Sidebar (previous queries)
-            with gr.Column(scale=0, min_width=260, visible=False, elem_classes=["query-sidebar"]) as sidebar:
-                gr.Markdown("### Previous Queries", elem_classes=["sidebar-header"])
-                sidebar_list = gr.Column(elem_id="sidebar-queries")
-                btn_new_query = gr.Button("+ New Query", size="sm", variant="primary")
-
-            # Main content
-            with gr.Column(scale=4, elem_classes=["main-content"]):
-
-                # Input view (greeting style)
-                with gr.Group(visible=True, elem_classes=["input-greeting"]) as view_input:
-                    gr.Markdown("What would you like to analyze?", elem_classes=["greeting-title"])
-                    gr.Markdown("Upload an image and describe what you'd like to know", elem_classes=["greeting-subtitle"])
-
-                    with gr.Column(elem_classes=["input-box-container"]):
-                        input_message = gr.Textbox(
-                            placeholder="Describe the lesion or ask a question...",
-                            show_label=False,
-                            lines=2,
-                            elem_classes=["message-input"]
-                        )
-
-                        input_image = gr.Image(
-                            type="pil",
-                            height=180,
-                            show_label=False,
-                            elem_classes=["image-preview"]
-                        )
-
-                        with gr.Row(elem_classes=["input-actions"]):
-                            gr.Markdown("*Upload a skin lesion image*")
-                            btn_analyze = gr.Button("Analyze", elem_classes=["send-btn"], interactive=False)
-
-                # Results view (shown after analysis)
-                with gr.Group(visible=False, elem_classes=["chat-view"]) as view_results:
-                    output_html = gr.HTML(
-                        value='<div class="analysis-output">Starting...</div>',
-                        elem_classes=["results-area"]
-                    )
-
-                    # Confirmation
-                    with gr.Group(visible=False, elem_classes=["confirm-buttons"]) as confirm_box:
-                        gr.Markdown("**Do you agree with this diagnosis?**")
-                        with gr.Row():
-                            btn_confirm_yes = gr.Button("Yes, continue", variant="primary", size="sm")
-                            btn_confirm_no = gr.Button("No, I disagree", variant="secondary", size="sm")
-                        input_feedback = gr.Textbox(label="Your assessment", placeholder="Enter diagnosis...", visible=False)
-                        btn_submit_feedback = gr.Button("Submit", visible=False, size="sm")
-
-                    # Follow-up
-                    with gr.Row(elem_classes=["chat-input-area"]):
-                        input_followup = gr.Textbox(placeholder="Ask a follow-up question...", show_label=False, lines=1, scale=4)
-                        btn_followup = gr.Button("Send", size="sm", scale=1)
-
-    # =========================================================================
-    # DYNAMIC SIDEBAR RENDERING
-    # =========================================================================
-    @gr.render(inputs=[state], triggers=[state.change])
-    def render_sidebar(s):
-        case_id = s.get("case_id")
-        if not case_id or s.get("page") != "analysis":
-            return
-
-        instances = case_store.list_instances(case_id)
-        current = s.get("instance_id")
-
-        for i, inst in enumerate(instances, 1):
-            diagnosis = "Pending"
-            if inst.analysis and inst.analysis.get("diagnosis"):
-                d = inst.analysis["diagnosis"]
-                diagnosis = d.get("class", "?")
-
-            label = f"#{i}: {diagnosis}"
-            variant = "primary" if inst.id == current else "secondary"
-            btn = gr.Button(label, size="sm", variant=variant, elem_classes=["query-item"])
-
-            # Attach click handler to load this instance
-            def load_instance(inst_id=inst.id, c_id=case_id):
-                def _load(current_state):
-                    current_state["instance_id"] = inst_id
-                    instance = case_store.get_instance(c_id, inst_id)
-
-                    # Load saved output if available
-                    output_html = '<div class="analysis-output"><div class="result">Previous analysis loaded</div></div>'
-                    if instance and instance.analysis:
-                        diag = instance.analysis.get("diagnosis", {})
-                        output_html = f'<div class="analysis-output"><div class="result">Diagnosis: {diag.get("full_name", diag.get("class", "Unknown"))}</div></div>'
-
-                    return (
-                        current_state,
-                        gr.update(visible=False),  # view_input
-                        gr.update(visible=True),   # view_results
-                        output_html,
-                        gr.update(visible=False)   # confirm_box
-                    )
-                return _load
-
-            btn.click(
-                load_instance(),
-                inputs=[state],
-                outputs=[state, view_input, view_results, output_html, confirm_box]
-            )
-
-    # =========================================================================
-    # EVENT HANDLERS
-    # =========================================================================
-
-    def select_patient(case_id: str, s: Dict):
-        """Handle patient selection"""
-        s["case_id"] = case_id
-        s["page"] = "analysis"
-
-        instances = case_store.list_instances(case_id)
-        has_queries = len(instances) > 0
-
-        if has_queries:
-            # Load most recent
-            inst = instances[-1]
-            s["instance_id"] = inst.id
-
-            # Load image if exists
-            img = None
-            if inst.image_path and os.path.exists(inst.image_path):
-                from PIL import Image
-                img = Image.open(inst.image_path)
-
-            return (
-                s,
-                gr.update(visible=False),  # page_patient
-                gr.update(visible=True),   # page_analysis
-                gr.update(visible=True),   # sidebar
-                gr.update(visible=False),  # view_input
-                gr.update(visible=True),   # view_results
-                '<div class="analysis-output"><div class="result">Previous analysis loaded</div></div>',
-                gr.update(visible=False)   # confirm_box
-            )
-        else:
-            # New instance
-            inst = case_store.create_instance(case_id)
-            s["instance_id"] = inst.id
-            s["output"] = ""
-
-            return (
-                s,
-                gr.update(visible=False),
-                gr.update(visible=True),
-                gr.update(visible=False),  # sidebar hidden for new patient
-                gr.update(visible=True),   # view_input
-                gr.update(visible=False),  # view_results
-                "",
-                gr.update(visible=False)
-            )
-
-    def new_patient(s: Dict):
-        """Create new patient"""
-        case = case_store.create_case(f"Patient {datetime.now().strftime('%Y-%m-%d %H:%M')}")
-        return select_patient(case.id, s)
-
-    def go_back(s: Dict):
-        """Return to patient selection"""
-        s["page"] = "patient_select"
-        s["case_id"] = None
-        s["instance_id"] = None
-        s["output"] = ""
-
-        return (
-            s,
-            gr.update(visible=True),   # page_patient
-            gr.update(visible=False),  # page_analysis
-            gr.update(visible=False),  # sidebar
-            gr.update(visible=True),   # view_input
-            gr.update(visible=False),  # view_results
-            "",
-            gr.update(visible=False)   # confirm_box
-        )
-
-    def new_query(s: Dict):
-        """Start new query for current patient"""
-        case_id = s.get("case_id")
-        if not case_id:
-            return s, gr.update(), gr.update(), gr.update(), "", gr.update()
-
-        inst = case_store.create_instance(case_id)
-        s["instance_id"] = inst.id
-        s["output"] = ""
-        s["gradcam_base64"] = None
-
-        agent.reset()
-
-        return (
-            s,
-            gr.update(visible=True),   # view_input
-            gr.update(visible=False),  # view_results
-            None,                       # clear image
-            "",                         # clear output
-            gr.update(visible=False)   # confirm_box
-        )
-
-    def enable_analyze(img):
-        """Enable analyze button when image uploaded"""
-        return gr.update(interactive=img is not None)
-
-    def run_analysis(image, message, s: Dict):
-        """Run analysis on uploaded image"""
-        if image is None:
-            yield s, gr.update(), gr.update(), gr.update(), gr.update()
-            return
-
-        case_id = s["case_id"]
-        instance_id = s["instance_id"]
-
-        # Save image
-        image_path = case_store.save_image(case_id, instance_id, image)
-        case_store.update_analysis(case_id, instance_id, stage="analyzing", image_path=image_path)
-
-        agent.reset()
-        s["output"] = ""
-        gradcam_base64 = None
-        has_confirm = False
-
-        # Switch to results view
-        yield (
-            s,
-            gr.update(visible=False),  # view_input
-            gr.update(visible=True),   # view_results
-            '<div class="analysis-output">Starting analysis...</div>',
-            gr.update(visible=False)   # confirm_box
-        )
-
-        partial = ""
-        for chunk in agent.analyze(image_path, message or ""):
-            partial += chunk
-
-            # Check for GradCAM
-            if gradcam_base64 is None:
-                match = re.search(r'\[GRADCAM_IMAGE:([^\]]+)\]', partial)
-                if match:
-                    path = match.group(1)
-                    if os.path.exists(path):
-                        try:
-                            with open(path, "rb") as f:
-                                gradcam_base64 = base64.b64encode(f.read()).decode('utf-8')
-                            s["gradcam_base64"] = gradcam_base64
-                        except:
-                            pass
-
-            if '[CONFIRM:' in partial:
-                has_confirm = True
-
-            s["output"] = partial
-
-            yield (
-                s,
-                gr.update(visible=False),
-                gr.update(visible=True),
-                format_output(partial, gradcam_base64),
-                gr.update(visible=has_confirm)
-            )
-
-        # Save analysis
-        if agent.model and agent.model.last_diagnosis:
-            diag = agent.model.last_diagnosis["predictions"][0]
-            case_store.update_analysis(
-                case_id, instance_id,
-                stage="awaiting_confirmation",
-                analysis={"diagnosis": diag}
-            )
-
-    def confirm_yes(s: Dict):
-        """User confirmed diagnosis"""
-        partial = s.get("output", "")
-        gradcam = s.get("gradcam_base64")
-
-        for chunk in agent.management_guidance(confirmed=True):
-            partial += chunk
-            s["output"] = partial
-            yield s, format_output(partial, gradcam), gr.update(visible=False)
-
-        case_store.update_analysis(s["case_id"], s["instance_id"], stage="complete")
-
-    def confirm_no():
-        """Show feedback input"""
-        return gr.update(visible=True), gr.update(visible=True)
-
-    def submit_feedback(feedback: str, s: Dict):
-        """Submit user feedback"""
-        partial = s.get("output", "")
-        gradcam = s.get("gradcam_base64")
-
-        for chunk in agent.management_guidance(confirmed=False, feedback=feedback):
-            partial += chunk
-            s["output"] = partial
-            yield (
-                s,
-                format_output(partial, gradcam),
-                gr.update(visible=False),
-                gr.update(visible=False),
-                gr.update(visible=False),
-                ""
-            )
-
-        case_store.update_analysis(s["case_id"], s["instance_id"], stage="complete")
-
-    def send_followup(message: str, s: Dict):
-        """Send follow-up question"""
-        if not message.strip():
-            return s, gr.update(), ""
-
-        case_store.add_chat_message(s["case_id"], s["instance_id"], "user", message)
-
-        partial = s.get("output", "")
-        gradcam = s.get("gradcam_base64")
-
-        partial += f'\n<div class="chat-message user">You: {message}</div>\n'
-
-        response = ""
-        for chunk in agent.followup(message):
-            response += chunk
-            s["output"] = partial + response
-            yield s, format_output(partial + response, gradcam), ""
-
-        case_store.add_chat_message(s["case_id"], s["instance_id"], "assistant", response)
-
-    # =========================================================================
-    # WIRE EVENTS
-    # =========================================================================
-
-    # Patient selection
-    btn_demo_melanoma.click(
-        lambda s: select_patient("demo-melanoma", s),
-        inputs=[state],
-        outputs=[state, page_patient, page_analysis, sidebar, view_input, view_results, output_html, confirm_box]
-    )
-
-    btn_demo_ak.click(
-        lambda s: select_patient("demo-ak", s),
-        inputs=[state],
-        outputs=[state, page_patient, page_analysis, sidebar, view_input, view_results, output_html, confirm_box]
-    )
-
-    btn_new_patient.click(
-        new_patient,
-        inputs=[state],
-        outputs=[state, page_patient, page_analysis, sidebar, view_input, view_results, output_html, confirm_box]
-    )
-
-    # Navigation
-    btn_back.click(
-        go_back,
-        inputs=[state],
-        outputs=[state, page_patient, page_analysis, sidebar, view_input, view_results, output_html, confirm_box]
-    )
-
-    btn_new_query.click(
-        new_query,
-        inputs=[state],
-        outputs=[state, view_input, view_results, input_image, output_html, confirm_box]
-    )
-
-    # Analysis
-    input_image.change(enable_analyze, inputs=[input_image], outputs=[btn_analyze])
-
-    btn_analyze.click(
-        run_analysis,
-        inputs=[input_image, input_message, state],
-        outputs=[state, view_input, view_results, output_html, confirm_box]
-    )
-
-    # Confirmation
-    btn_confirm_yes.click(
-        confirm_yes,
-        inputs=[state],
-        outputs=[state, output_html, confirm_box]
-    )
-
-    btn_confirm_no.click(
-        confirm_no,
-        outputs=[input_feedback, btn_submit_feedback]
-    )
-
-    btn_submit_feedback.click(
-        submit_feedback,
-        inputs=[input_feedback, state],
-        outputs=[state, output_html, confirm_box, input_feedback, btn_submit_feedback, input_feedback]
-    )
-
-    # Follow-up
-    btn_followup.click(
-        send_followup,
-        inputs=[input_followup, state],
-        outputs=[state, output_html, input_followup]
-    )
-
-    input_followup.submit(
-        send_followup,
-        inputs=[input_followup, state],
-        outputs=[state, output_html, input_followup]
-    )
-
-
-# =============================================================================
-# MAIN
-# =============================================================================
-
-if __name__ == "__main__":
-    print(f"\n{'='*50}")
-    print(f"  {Config.APP_TITLE}")
-    print(f"{'='*50}\n")
-
-    app.queue().launch(
-        server_name="0.0.0.0" if Config.HF_SPACES else "127.0.0.1",
-        server_port=Config.SERVER_PORT,
-        share=False,
-        show_error=True
-    )

frontend/components/analysis_view.py

@@ -1,214 +0,0 @@
-"""
-Analysis View Component - Main analysis interface with input and results
-"""
-
-import gradio as gr
-import re
-from typing import Optional
-
-
-def parse_markdown(text: str) -> str:
-    """Convert basic markdown to HTML"""
-    text = re.sub(r'\*\*(.+?)\*\*', r'<strong>\1</strong>', text)
-    text = re.sub(r'__(.+?)__', r'<strong>\1</strong>', text)
-    text = re.sub(r'\*(.+?)\*', r'<em>\1</em>', text)
-
-    # Bullet lists
-    lines = text.split('\n')
-    in_list = False
-    result = []
-    for line in lines:
-        stripped = line.strip()
-        if re.match(r'^[\*\-] ', stripped):
-            if not in_list:
-                result.append('<ul>')
-                in_list = True
-            item = re.sub(r'^[\*\-] ', '', stripped)
-            result.append(f'<li>{item}</li>')
-        else:
-            if in_list:
-                result.append('</ul>')
-                in_list = False
-            result.append(line)
-    if in_list:
-        result.append('</ul>')
-
-    return '\n'.join(result)
-
-
-# Regex patterns for output parsing
-_STAGE_RE = re.compile(r'\[STAGE:(\w+)\](.*?)\[/STAGE\]')
-_THINKING_RE = re.compile(r'\[THINKING\](.*?)\[/THINKING\]')
-_OBSERVATION_RE = re.compile(r'\[OBSERVATION\](.*?)\[/OBSERVATION\]')
-_TOOL_OUTPUT_RE = re.compile(r'\[TOOL_OUTPUT:(.*?)\]\n(.*?)\[/TOOL_OUTPUT\]', re.DOTALL)
-_RESULT_RE = re.compile(r'\[RESULT\](.*?)\[/RESULT\]')
-_ERROR_RE = re.compile(r'\[ERROR\](.*?)\[/ERROR\]')
-_GRADCAM_RE = re.compile(r'\[GRADCAM_IMAGE:[^\]]+\]\n?')
-_RESPONSE_RE = re.compile(r'\[RESPONSE\]\n(.*?)\n\[/RESPONSE\]', re.DOTALL)
-_COMPLETE_RE = re.compile(r'\[COMPLETE\](.*?)\[/COMPLETE\]')
-_CONFIRM_RE = re.compile(r'\[CONFIRM:(\w+)\](.*?)\[/CONFIRM\]')
-_REFERENCES_RE = re.compile(r'\[REFERENCES\](.*?)\[/REFERENCES\]', re.DOTALL)
-_REF_RE = re.compile(r'\[REF:([^:]+):([^:]+):([^:]+):([^:]+):([^\]]+)\]')
-
-
-def format_output(raw_text: str, gradcam_base64: Optional[str] = None) -> str:
-    """Convert tagged output to styled HTML"""
-    html = raw_text
-
-    # Stage headers
-    html = _STAGE_RE.sub(
-        r'<div class="stage"><span class="stage-indicator"></span><span class="stage-text">\2</span></div>',
-        html
-    )
-
-    # Thinking
-    html = _THINKING_RE.sub(r'<div class="thinking">\1</div>', html)
-
-    # Observations
-    html = _OBSERVATION_RE.sub(r'<div class="observation">\1</div>', html)
-
-    # Tool outputs
-    html = _TOOL_OUTPUT_RE.sub(
-        r'<div class="tool-output"><div class="tool-header">\1</div><pre class="tool-content">\2</pre></div>',
-        html
-    )
-
-    # Results
-    html = _RESULT_RE.sub(r'<div class="result">\1</div>', html)
-
-    # Errors
-    html = _ERROR_RE.sub(r'<div class="error">\1</div>', html)
-
-    # GradCAM image
-    if gradcam_base64:
-        img_html = f'<div class="gradcam-inline"><div class="gradcam-header">Attention Map</div><img src="data:image/png;base64,{gradcam_base64}" alt="Grad-CAM"></div>'
-        html = _GRADCAM_RE.sub(img_html, html)
-    else:
-        html = _GRADCAM_RE.sub('', html)
-
-    # Response section
-    def format_response(match):
-        content = match.group(1)
-        parsed = parse_markdown(content)
-        parsed = re.sub(r'\n\n+', '</p><p>', parsed)
-        parsed = parsed.replace('\n', '<br>')
-        return f'<div class="response"><p>{parsed}</p></div>'
-
-    html = _RESPONSE_RE.sub(format_response, html)
-
-    # Complete
-    html = _COMPLETE_RE.sub(r'<div class="complete">\1</div>', html)
-
-    # Confirmation
-    html = _CONFIRM_RE.sub(
-        r'<div class="confirm-box"><div class="confirm-text">\2</div></div>',
-        html
-    )
-
-    # References
-    def format_references(match):
-        ref_content = match.group(1)
-        refs_html = ['<div class="references"><div class="references-header">References</div><ul>']
-        for ref_match in _REF_RE.finditer(ref_content):
-            _, source, page, filename, superscript = ref_match.groups()
-            refs_html.append(
-                f'<li><a href="guidelines/{filename}#page={page}" target="_blank" class="ref-link">'
-                f'<sup>{superscript}</sup> {source}, p.{page}</a></li>'
-            )
-        refs_html.append('</ul></div>')
-        return '\n'.join(refs_html)
-
-    html = _REFERENCES_RE.sub(format_references, html)
-
-    # Convert newlines
-    html = html.replace('\n', '<br>')
-
-    return f'<div class="analysis-output">{html}</div>'
-
-
-def create_analysis_view():
-    """
-    Create the analysis view component.
-
-    Returns:
-        Tuple of (container, components dict)
-    """
-    with gr.Group(visible=False, elem_classes=["analysis-container"]) as container:
-
-        with gr.Row():
-            # Main content area
-            with gr.Column(elem_classes=["main-content"]):
-
-                # Input greeting (shown when no analysis yet)
-                with gr.Group(visible=True, elem_classes=["input-greeting"]) as input_greeting:
-                    gr.Markdown("What would you like to analyze?", elem_classes=["greeting-title"])
-                    gr.Markdown("Upload an image and describe what you'd like to know", elem_classes=["greeting-subtitle"])
-
-                    with gr.Column(elem_classes=["input-box-container"]):
-                        message_input = gr.Textbox(
-                            placeholder="Describe the lesion or ask a question...",
-                            show_label=False,
-                            lines=3,
-                            elem_classes=["message-input"]
-                        )
-
-                        # Image upload (compact)
-                        image_input = gr.Image(
-                            label="",
-                            type="pil",
-                            height=180,
-                            elem_classes=["image-preview"],
-                            show_label=False
-                        )
-
-                        with gr.Row(elem_classes=["input-actions"]):
-                            upload_hint = gr.Markdown("*Upload a skin lesion image above*", visible=True)
-                            send_btn = gr.Button("Analyze", elem_classes=["send-btn"], interactive=False)
-
-                # Chat/results view (shown after analysis starts)
-                with gr.Group(visible=False, elem_classes=["chat-view"]) as chat_view:
-                    results_output = gr.HTML(
-                        value='<div class="analysis-output">Starting analysis...</div>',
-                        elem_classes=["results-area"]
-                    )
-
-                    # Confirmation buttons
-                    with gr.Group(visible=False, elem_classes=["confirm-buttons"]) as confirm_group:
-                        gr.Markdown("**Do you agree with this diagnosis?**")
-                        with gr.Row():
-                            confirm_yes_btn = gr.Button("Yes, continue", variant="primary", size="sm")
-                            confirm_no_btn = gr.Button("No, I disagree", variant="secondary", size="sm")
-                        feedback_input = gr.Textbox(
-                            label="Your assessment",
-                            placeholder="Enter your diagnosis...",
-                            visible=False
-                        )
-                        submit_feedback_btn = gr.Button("Submit", visible=False, size="sm")
-
-                    # Follow-up input
-                    with gr.Row(elem_classes=["chat-input-area"]):
-                        followup_input = gr.Textbox(
-                            placeholder="Ask a follow-up question...",
-                            show_label=False,
-                            lines=1
-                        )
-                        followup_btn = gr.Button("Send", size="sm", elem_classes=["send-btn"])
-
-    components = {
-        "input_greeting": input_greeting,
-        "chat_view": chat_view,
-        "message_input": message_input,
-        "image_input": image_input,
-        "send_btn": send_btn,
-        "results_output": results_output,
-        "confirm_group": confirm_group,
-        "confirm_yes_btn": confirm_yes_btn,
-        "confirm_no_btn": confirm_no_btn,
-        "feedback_input": feedback_input,
-        "submit_feedback_btn": submit_feedback_btn,
-        "followup_input": followup_input,
-        "followup_btn": followup_btn,
-        "upload_hint": upload_hint
-    }
-
-    return container, components

frontend/components/patient_select.py

@@ -1,48 +0,0 @@
-"""
-Patient Selection Component - Landing page for selecting/creating patients
-"""
-
-import gradio as gr
-from typing import Callable, List
-from data.case_store import get_case_store, Case
-
-
-def create_patient_select(on_patient_selected: Callable[[str], None]) -> gr.Group:
-    """
-    Create the patient selection page component.
-
-    Args:
-        on_patient_selected: Callback when a patient is selected (receives case_id)
-
-    Returns:
-        gr.Group containing the patient selection UI
-    """
-    case_store = get_case_store()
-
-    with gr.Group(visible=True, elem_classes=["patient-select-container"]) as container:
-        gr.Markdown("# SkinProAI", elem_classes=["patient-select-title"])
-        gr.Markdown("Select a patient to continue or create a new case", elem_classes=["patient-select-subtitle"])
-
-        with gr.Column(elem_classes=["patient-grid"]):
-            # Demo cases
-            demo_melanoma_btn = gr.Button(
-                "Demo: Melanocytic Lesion",
-                elem_classes=["patient-card"]
-            )
-            demo_ak_btn = gr.Button(
-                "Demo: Actinic Keratosis",
-                elem_classes=["patient-card"]
-            )
-
-            # New patient button
-            new_patient_btn = gr.Button(
-                "+ New Patient",
-                elem_classes=["new-patient-btn"]
-            )
-
-    return container, demo_melanoma_btn, demo_ak_btn, new_patient_btn
-
-
-def get_patient_cases() -> List[Case]:
-    """Get list of all patient cases"""
-    return get_case_store().list_cases()

frontend/components/sidebar.py

@@ -1,55 +0,0 @@
-"""
-Sidebar Component - Shows previous queries for a patient
-"""
-
-import gradio as gr
-from datetime import datetime
-from typing import List, Optional
-from data.case_store import get_case_store, Instance
-
-
-def format_query_item(instance: Instance, index: int) -> str:
-    """Format an instance as a query item for display"""
-    diagnosis = "Pending"
-    if instance.analysis and instance.analysis.get("diagnosis"):
-        diag = instance.analysis["diagnosis"]
-        diagnosis = diag.get("full_name", diag.get("class", "Unknown"))
-
-    try:
-        dt = datetime.fromisoformat(instance.created_at.replace('Z', '+00:00'))
-        date_str = dt.strftime("%b %d, %H:%M")
-    except:
-        date_str = "Unknown"
-
-    return f"Query #{index}: {diagnosis} ({date_str})"
-
-
-def create_sidebar():
-    """
-    Create the sidebar component for showing previous queries.
-
-    Returns:
-        Tuple of (container, components dict)
-    """
-    with gr.Column(visible=False, elem_classes=["query-sidebar"]) as container:
-        gr.Markdown("### Previous Queries", elem_classes=["sidebar-header"])
-
-        # Dynamic list of query buttons
-        query_list = gr.Column(elem_id="query-list")
-
-        # New query button
-        new_query_btn = gr.Button("+ New Query", size="sm", variant="primary")
-
-    components = {
-        "query_list": query_list,
-        "new_query_btn": new_query_btn
-    }
-
-    return container, components
-
-
-def get_queries_for_case(case_id: str) -> List[Instance]:
-    """Get all instances/queries for a case"""
-    if not case_id:
-        return []
-    return get_case_store().list_instances(case_id)

frontend/components/styles.py

@@ -1,517 +0,0 @@
-"""
-CSS Styles for SkinProAI components
-"""
-
-MAIN_CSS = """
-@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap');
-
-* {
-    font-family: 'Inter', sans-serif !important;
-}
-
-.gradio-container {
-    max-width: 1200px !important;
-    margin: 0 auto !important;
-}
-
-/* Hide Gradio footer */
-.gradio-container footer { display: none !important; }
-
-/* ============================================
-   PATIENT SELECTION PAGE
-   ============================================ */
-
-.patient-select-container {
-    min-height: 80vh;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    padding: 40px 20px;
-}
-
-.patient-select-title {
-    font-size: 32px;
-    font-weight: 600;
-    color: #111827;
-    margin-bottom: 8px;
-    text-align: center;
-}
-
-.patient-select-subtitle {
-    font-size: 16px;
-    color: #6b7280;
-    margin-bottom: 40px;
-    text-align: center;
-}
-
-.patient-grid {
-    display: flex;
-    gap: 20px;
-    flex-wrap: wrap;
-    justify-content: center;
-    max-width: 800px;
-}
-
-.patient-card {
-    background: white !important;
-    border: 2px solid #e5e7eb !important;
-    border-radius: 16px !important;
-    padding: 24px 32px !important;
-    min-width: 200px !important;
-    cursor: pointer;
-    transition: all 0.2s ease !important;
-}
-
-.patient-card:hover {
-    border-color: #6366f1 !important;
-    box-shadow: 0 8px 25px rgba(99, 102, 241, 0.15) !important;
-    transform: translateY(-2px);
-}
-
-.new-patient-btn {
-    background: #6366f1 !important;
-    color: white !important;
-    border: none !important;
-    border-radius: 12px !important;
-    padding: 16px 32px !important;
-    font-weight: 500 !important;
-    margin-top: 24px;
-}
-
-.new-patient-btn:hover {
-    background: #4f46e5 !important;
-}
-
-/* ============================================
-   ANALYSIS PAGE - MAIN LAYOUT
-   ============================================ */
-
-.analysis-container {
-    display: flex;
-    height: calc(100vh - 80px);
-    min-height: 600px;
-}
-
-/* Sidebar */
-.query-sidebar {
-    width: 280px;
-    background: #f9fafb;
-    border-right: 1px solid #e5e7eb;
-    padding: 20px;
-    overflow-y: auto;
-    flex-shrink: 0;
-}
-
-.sidebar-header {
-    font-size: 14px;
-    font-weight: 600;
-    color: #374151;
-    margin-bottom: 16px;
-    padding-bottom: 12px;
-    border-bottom: 1px solid #e5e7eb;
-}
-
-.query-item {
-    background: white;
-    border: 1px solid #e5e7eb;
-    border-radius: 8px;
-    padding: 12px;
-    margin-bottom: 8px;
-    cursor: pointer;
-    transition: all 0.15s;
-}
-
-.query-item:hover {
-    border-color: #6366f1;
-    background: #f5f3ff;
-}
-
-.query-item-title {
-    font-size: 13px;
-    font-weight: 500;
-    color: #111827;
-    margin-bottom: 4px;
-}
-
-.query-item-meta {
-    font-size: 11px;
-    color: #6b7280;
-}
-
-/* Main content area */
-.main-content {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    padding: 24px;
-    overflow: hidden;
-}
-
-/* ============================================
-   INPUT AREA (Greeting style)
-   ============================================ */
-
-.input-greeting {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    padding: 40px;
-}
-
-.greeting-title {
-    font-size: 24px;
-    font-weight: 600;
-    color: #111827;
-    margin-bottom: 8px;
-}
-
-.greeting-subtitle {
-    font-size: 14px;
-    color: #6b7280;
-    margin-bottom: 32px;
-}
-
-.input-box-container {
-    width: 100%;
-    max-width: 600px;
-    background: white;
-    border: 2px solid #e5e7eb;
-    border-radius: 16px;
-    padding: 20px;
-    transition: border-color 0.2s;
-}
-
-.input-box-container:focus-within {
-    border-color: #6366f1;
-}
-
-.message-input textarea {
-    border: none !important;
-    resize: none !important;
-    font-size: 15px !important;
-    line-height: 1.5 !important;
-    padding: 0 !important;
-}
-
-.message-input textarea:focus {
-    box-shadow: none !important;
-}
-
-.input-actions {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    margin-top: 16px;
-    padding-top: 16px;
-    border-top: 1px solid #f3f4f6;
-}
-
-.upload-btn {
-    background: #f3f4f6 !important;
-    color: #374151 !important;
-    border: 1px solid #e5e7eb !important;
-    border-radius: 8px !important;
-    padding: 8px 16px !important;
-    font-size: 13px !important;
-}
-
-.upload-btn:hover {
-    background: #e5e7eb !important;
-}
-
-.send-btn {
-    background: #6366f1 !important;
-    color: white !important;
-    border: none !important;
-    border-radius: 8px !important;
-    padding: 10px 24px !important;
-    font-weight: 500 !important;
-}
-
-.send-btn:hover {
-    background: #4f46e5 !important;
-}
-
-.send-btn:disabled {
-    background: #d1d5db !important;
-    cursor: not-allowed;
-}
-
-/* Image preview */
-.image-preview {
-    margin-top: 16px;
-    border-radius: 12px;
-    overflow: hidden;
-    max-height: 200px;
-}
-
-.image-preview img {
-    max-height: 200px;
-    object-fit: contain;
-}
-
-/* ============================================
-   CHAT/RESULTS VIEW
-   ============================================ */
-
-.chat-view {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    overflow: hidden;
-}
-
-.results-area {
-    flex: 1;
-    overflow-y: auto;
-    padding: 20px;
-    background: #ffffff;
-    border: 1px solid #e5e7eb;
-    border-radius: 12px;
-    margin-bottom: 16px;
-}
-
-/* Analysis output styling */
-.analysis-output {
-    line-height: 1.6;
-    color: #333;
-}
-
-.stage {
-    display: flex;
-    align-items: center;
-    gap: 10px;
-    padding: 8px 0;
-    font-weight: 500;
-    color: #1a1a1a;
-    margin-top: 12px;
-}
-
-.stage-indicator {
-    width: 8px;
-    height: 8px;
-    background: #6366f1;
-    border-radius: 50%;
-    animation: pulse 1.5s ease-in-out infinite;
-}
-
-@keyframes pulse {
-    0%, 100% { opacity: 1; transform: scale(1); }
-    50% { opacity: 0.5; transform: scale(0.8); }
-}
-
-.thinking {
-    color: #6b7280;
-    font-style: italic;
-    font-size: 13px;
-    padding: 4px 0 4px 16px;
-    border-left: 2px solid #e5e7eb;
-    margin: 4px 0;
-}
-
-.observation {
-    color: #374151;
-    font-size: 13px;
-    padding: 4px 0 4px 16px;
-}
-
-.tool-output {
-    background: #f8fafc;
-    border-radius: 8px;
-    margin: 12px 0;
-    overflow: hidden;
-    border: 1px solid #e2e8f0;
-}
-
-.tool-header {
-    background: #f1f5f9;
-    padding: 8px 12px;
-    font-weight: 500;
-    font-size: 13px;
-    color: #475569;
-    border-bottom: 1px solid #e2e8f0;
-}
-
-.tool-content {
-    padding: 12px;
-    margin: 0;
-    font-family: 'SF Mono', Monaco, monospace !important;
-    font-size: 12px;
-    line-height: 1.5;
-    white-space: pre-wrap;
-    color: #334155;
-}
-
-.result {
-    background: #ecfdf5;
-    border: 1px solid #a7f3d0;
-    border-radius: 8px;
-    padding: 12px 16px;
-    margin: 12px 0;
-    font-weight: 500;
-    color: #065f46;
-}
-
-.error {
-    background: #fef2f2;
-    border: 1px solid #fecaca;
-    border-radius: 8px;
-    padding: 12px 16px;
-    margin: 8px 0;
-    color: #b91c1c;
-}
-
-.response {
-    background: #ffffff;
-    border: 1px solid #e5e7eb;
-    border-radius: 8px;
-    padding: 16px;
-    margin: 16px 0;
-    line-height: 1.7;
-}
-
-.response ul, .response ol {
-    margin: 8px 0;
-    padding-left: 24px;
-}
-
-.response li {
-    margin: 4px 0;
-}
-
-.complete {
-    color: #6b7280;
-    font-size: 12px;
-    padding: 8px 0;
-    text-align: center;
-}
-
-/* Confirmation */
-.confirm-box {
-    background: #eff6ff;
-    border: 1px solid #bfdbfe;
-    border-radius: 8px;
-    padding: 16px;
-    margin: 16px 0;
-    text-align: center;
-}
-
-.confirm-buttons {
-    background: #f0f9ff;
-    border: 1px solid #bae6fd;
-    border-radius: 8px;
-    padding: 12px;
-    margin-top: 12px;
-}
-
-/* References */
-.references {
-    background: #f9fafb;
-    border: 1px solid #e5e7eb;
-    border-radius: 8px;
-    margin: 16px 0;
-    overflow: hidden;
-}
-
-.references-header {
-    background: #f3f4f6;
-    padding: 8px 12px;
-    font-weight: 500;
-    font-size: 13px;
-    border-bottom: 1px solid #e5e7eb;
-}
-
-.references ul {
-    list-style: none;
-    padding: 12px;
-    margin: 0;
-}
-
-.ref-link {
-    color: #6366f1;
-    text-decoration: none;
-    font-size: 13px;
-}
-
-.ref-link:hover {
-    text-decoration: underline;
-}
-
-/* GradCAM */
-.gradcam-inline {
-    margin: 16px 0;
-    background: #f8fafc;
-    border-radius: 8px;
-    overflow: hidden;
-    border: 1px solid #e2e8f0;
-}
-
-.gradcam-header {
-    background: #f1f5f9;
-    padding: 8px 12px;
-    font-weight: 500;
-    font-size: 13px;
-    border-bottom: 1px solid #e2e8f0;
-}
-
-.gradcam-inline img {
-    max-width: 100%;
-    max-height: 300px;
-    display: block;
-    margin: 12px auto;
-}
-
-/* Chat input at bottom */
-.chat-input-area {
-    background: white;
-    border: 1px solid #e5e7eb;
-    border-radius: 12px;
-    padding: 12px 16px;
-    display: flex;
-    gap: 12px;
-    align-items: flex-end;
-}
-
-.chat-input-area textarea {
-    flex: 1;
-    border: none !important;
-    resize: none !important;
-    font-size: 14px !important;
-}
-
-/* ============================================
-   HEADER
-   ============================================ */
-
-.app-header {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    padding: 16px 24px;
-    border-bottom: 1px solid #e5e7eb;
-    background: white;
-}
-
-.app-title {
-    font-size: 20px;
-    font-weight: 600;
-    color: #111827;
-}
-
-.back-btn {
-    background: transparent !important;
-    color: #6b7280 !important;
-    border: 1px solid #e5e7eb !important;
-    border-radius: 8px !important;
-    padding: 8px 16px !important;
-    font-size: 13px !important;
-}
-
-.back-btn:hover {
-    background: #f9fafb !important;
-    color: #111827 !important;
-}
-"""

models/explainability.py

@@ -1,183 +0,0 @@
-# models/explainability.py
-
-import torch
-import torch.nn.functional as F
-import numpy as np
-import cv2
-from typing import Tuple
-from PIL import Image
-
-class GradCAM:
-    """
-    Gradient-weighted Class Activation Mapping
-    Shows which regions of image are important for prediction
-    """
-    
-    def __init__(self, model: torch.nn.Module, target_layer: str = None):
-        """
-        Args:
-            model: The neural network
-            target_layer: Layer name to compute CAM on (usually last conv layer)
-        """
-        self.model = model
-        self.gradients = None
-        self.activations = None
-        
-        # Auto-detect target layer if not specified
-        if target_layer is None:
-            # Use last ConvNeXt stage
-            self.target_layer = model.convnext.stages[-1]
-        else:
-            self.target_layer = dict(model.named_modules())[target_layer]
-        
-        # Register hooks
-        self.target_layer.register_forward_hook(self._save_activation)
-        self.target_layer.register_full_backward_hook(self._save_gradient)
-    
-    def _save_activation(self, module, input, output):
-        """Save forward activations"""
-        self.activations = output.detach()
-    
-    def _save_gradient(self, module, grad_input, grad_output):
-        """Save backward gradients"""
-        self.gradients = grad_output[0].detach()
-    
-    def generate_cam(
-        self,
-        image: torch.Tensor,
-        target_class: int = None
-    ) -> np.ndarray:
-        """
-        Generate Class Activation Map
-        
-        Args:
-            image: Input image [1, 3, H, W]
-            target_class: Class to generate CAM for (None = predicted class)
-            
-        Returns:
-            cam: Activation map [H, W] normalized to 0-1
-        """
-        self.model.eval()
-        
-        # Forward pass
-        output = self.model(image)
-        
-        # Use predicted class if not specified
-        if target_class is None:
-            target_class = output.argmax(dim=1).item()
-        
-        # Zero gradients
-        self.model.zero_grad()
-        
-        # Backward pass for target class
-        output[0, target_class].backward()
-        
-        # Get gradients and activations
-        gradients = self.gradients[0]  # [C, H, W]
-        activations = self.activations[0]  # [C, H, W]
-        
-        # Global average pooling of gradients
-        weights = gradients.mean(dim=(1, 2))  # [C]
-        
-        # Weighted sum of activations
-        cam = torch.zeros(activations.shape[1:], dtype=torch.float32)
-        for i, w in enumerate(weights):
-            cam += w * activations[i]
-        
-        # ReLU
-        cam = F.relu(cam)
-        
-        # Normalize to 0-1
-        cam = cam.cpu().numpy()
-        cam = cam - cam.min()
-        if cam.max() > 0:
-            cam = cam / cam.max()
-        
-        return cam
-    
-    def overlay_cam_on_image(
-        self,
-        image: np.ndarray,  # [H, W, 3] RGB
-        cam: np.ndarray,    # [h, w]
-        alpha: float = 0.5,
-        colormap: int = cv2.COLORMAP_JET
-    ) -> np.ndarray:
-        """
-        Overlay CAM heatmap on original image
-        
-        Returns:
-            overlay: [H, W, 3] RGB image with heatmap
-        """
-        H, W = image.shape[:2]
-        
-        # Resize CAM to image size
-        cam_resized = cv2.resize(cam, (W, H))
-        
-        # Convert to heatmap
-        heatmap = cv2.applyColorMap(
-            np.uint8(255 * cam_resized),
-            colormap
-        )
-        heatmap = cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB)
-        
-        # Blend with original image
-        overlay = (alpha * heatmap + (1 - alpha) * image).astype(np.uint8)
-        
-        return overlay
-
-class AttentionVisualizer:
-    """Visualize MedSigLIP attention maps"""
-    
-    def __init__(self, model):
-        self.model = model
-    
-    def get_attention_maps(self, image: torch.Tensor) -> np.ndarray:
-        """
-        Extract attention maps from MedSigLIP
-        
-        Returns:
-            attention: [num_heads, H, W] attention weights
-        """
-        # Forward pass
-        with torch.no_grad():
-            _ = self.model(image)
-        
-        # Get last layer attention from MedSigLIP
-        # Shape: [batch, num_heads, seq_len, seq_len]
-        attention = self.model.medsiglip_features
-        
-        # Average across heads and extract spatial attention
-        # This is model-dependent - adjust based on MedSigLIP architecture
-        
-        # Placeholder implementation
-        # You'll need to adapt this to your specific MedSigLIP implementation
-        return np.random.rand(14, 14)  # Placeholder
-    
-    def overlay_attention(
-        self,
-        image: np.ndarray,
-        attention: np.ndarray,
-        alpha: float = 0.6
-    ) -> np.ndarray:
-        """Overlay attention map on image"""
-        H, W = image.shape[:2]
-        
-        # Resize attention to image size
-        attention_resized = cv2.resize(attention, (W, H))
-        
-        # Normalize
-        attention_resized = (attention_resized - attention_resized.min())
-        if attention_resized.max() > 0:
-            attention_resized = attention_resized / attention_resized.max()
-        
-        # Create colored overlay
-        heatmap = cv2.applyColorMap(
-            np.uint8(255 * attention_resized),
-            cv2.COLORMAP_VIRIDIS
-        )
-        heatmap = cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB)
-        
-        # Blend
-        overlay = (alpha * heatmap + (1 - alpha) * image).astype(np.uint8)
-        
-        return overlay

models/medsiglip_convnext_fusion.py

@@ -1,224 +0,0 @@
-# models/medsiglip_convnext_fusion.py
-
-import torch
-import torch.nn as nn
-from typing import Dict, List, Tuple, Optional
-import numpy as np
-import timm
-from transformers import AutoModel, AutoProcessor
-
-class MedSigLIPConvNeXtFusion(nn.Module):
-    """
-    Your trained MedSigLIP-ConvNeXt fusion model from MILK10 challenge
-    Supports 11-class skin lesion classification
-    """
-    
-    # Class names from your training
-    CLASS_NAMES = [
-        'AKIEC',      # Actinic Keratoses and Intraepithelial Carcinoma
-        'BCC',        # Basal Cell Carcinoma
-        'BEN_OTH',    # Benign Other
-        'BKL',        # Benign Keratosis-like Lesions
-        'DF',         # Dermatofibroma
-        'INF',        # Inflammatory
-        'MAL_OTH',    # Malignant Other
-        'MEL',        # Melanoma
-        'NV',         # Melanocytic Nevi
-        'SCCKA',      # Squamous Cell Carcinoma and Keratoacanthoma
-        'VASC'        # Vascular Lesions
-    ]
-    
-    def __init__(
-        self,
-        num_classes: int = 11,
-        medsiglip_model: str = "google/medsiglip-base",
-        convnext_variant: str = "convnext_base",
-        fusion_dim: int = 512,
-        dropout: float = 0.3,
-        metadata_dim: int = 20  # For metadata features
-    ):
-        super().__init__()
-        
-        self.num_classes = num_classes
-        
-        # MedSigLIP Vision Encoder
-        print(f"Loading MedSigLIP: {medsiglip_model}")
-        self.medsiglip = AutoModel.from_pretrained(medsiglip_model)
-        self.medsiglip_processor = AutoProcessor.from_pretrained(medsiglip_model)
-        
-        # ConvNeXt Backbone
-        print(f"Loading ConvNeXt: {convnext_variant}")
-        self.convnext = timm.create_model(
-            convnext_variant,
-            pretrained=True,
-            num_classes=0,
-            global_pool='avg'
-        )
-        
-        # Feature dimensions
-        self.medsiglip_dim = self.medsiglip.config.hidden_size  # 768
-        self.convnext_dim = self.convnext.num_features  # 1024
-        
-        # Optional metadata branch
-        self.use_metadata = metadata_dim > 0
-        if self.use_metadata:
-            self.metadata_encoder = nn.Sequential(
-                nn.Linear(metadata_dim, 64),
-                nn.LayerNorm(64),
-                nn.GELU(),
-                nn.Dropout(0.2),
-                nn.Linear(64, 32)
-            )
-            total_dim = self.medsiglip_dim + self.convnext_dim + 32
-        else:
-            total_dim = self.medsiglip_dim + self.convnext_dim
-        
-        # Fusion layers
-        self.fusion = nn.Sequential(
-            nn.Linear(total_dim, fusion_dim),
-            nn.LayerNorm(fusion_dim),
-            nn.GELU(),
-            nn.Dropout(dropout),
-            nn.Linear(fusion_dim, fusion_dim // 2),
-            nn.LayerNorm(fusion_dim // 2),
-            nn.GELU(),
-            nn.Dropout(dropout)
-        )
-        
-        # Classification head
-        self.classifier = nn.Linear(fusion_dim // 2, num_classes)
-        
-        # Store intermediate features for Grad-CAM
-        self.convnext_features = None
-        self.medsiglip_features = None
-        
-        # Register hooks
-        self.convnext.stages[-1].register_forward_hook(self._save_convnext_features)
-        
-    def _save_convnext_features(self, module, input, output):
-        """Hook to save ConvNeXt feature maps for Grad-CAM"""
-        self.convnext_features = output
-    
-    def forward(
-        self, 
-        image: torch.Tensor,
-        metadata: Optional[torch.Tensor] = None
-    ) -> torch.Tensor:
-        """
-        Forward pass
-        
-        Args:
-            image: [B, 3, H, W] tensor
-            metadata: [B, metadata_dim] optional metadata features
-            
-        Returns:
-            logits: [B, num_classes]
-        """
-        # MedSigLIP features
-        medsiglip_out = self.medsiglip.vision_model(image)
-        medsiglip_features = medsiglip_out.pooler_output  # [B, 768]
-        
-        # ConvNeXt features  
-        convnext_features = self.convnext(image)  # [B, 1024]
-        
-        # Concatenate vision features
-        fused = torch.cat([medsiglip_features, convnext_features], dim=1)
-        
-        # Add metadata if available
-        if self.use_metadata and metadata is not None:
-            metadata_features = self.metadata_encoder(metadata)
-            fused = torch.cat([fused, metadata_features], dim=1)
-        
-        # Fusion layers
-        fused = self.fusion(fused)
-        
-        # Classification
-        logits = self.classifier(fused)
-        
-        return logits
-    
-    def predict(
-        self,
-        image: torch.Tensor,
-        metadata: Optional[torch.Tensor] = None,
-        top_k: int = 5
-    ) -> Dict:
-        """
-        Get predictions with probabilities
-        
-        Args:
-            image: [B, 3, H, W] or [3, H, W]
-            metadata: Optional metadata features
-            top_k: Number of top predictions
-            
-        Returns:
-            Dictionary with predictions and features
-        """
-        if image.dim() == 3:
-            image = image.unsqueeze(0)
-        
-        self.eval()
-        with torch.no_grad():
-            logits = self.forward(image, metadata)
-            probs = torch.softmax(logits, dim=1)
-            
-            # Top-k predictions
-            top_probs, top_indices = torch.topk(
-                probs, 
-                k=min(top_k, self.num_classes), 
-                dim=1
-            )
-            
-            # Format results
-            predictions = []
-            for i in range(top_probs.size(1)):
-                predictions.append({
-                    'class': self.CLASS_NAMES[top_indices[0, i].item()],
-                    'probability': top_probs[0, i].item(),
-                    'class_idx': top_indices[0, i].item()
-                })
-        
-        return {
-            'predictions': predictions,
-            'all_probabilities': probs[0].cpu().numpy(),
-            'logits': logits[0].cpu().numpy(),
-            'convnext_features': self.convnext_features,
-            'medsiglip_features': self.medsiglip_features
-        }
-    
-    @classmethod
-    def load_from_checkpoint(
-        cls,
-        medsiglip_path: str,
-        convnext_path: Optional[str] = None,
-        ensemble_weights: tuple = (0.6, 0.4),
-        device: str = 'cpu'
-    ):
-        """
-        Load model from your training checkpoints
-        
-        Args:
-            medsiglip_path: Path to MedSigLIP model weights
-            convnext_path: Path to ConvNeXt model weights (optional)
-            ensemble_weights: (w_medsiglip, w_convnext) 
-            device: Device to load on
-        """
-        model = cls(num_classes=11)
-        
-        # Load MedSigLIP weights
-        print(f"Loading MedSigLIP from: {medsiglip_path}")
-        medsiglip_state = torch.load(medsiglip_path, map_location=device)
-        
-        # Handle different checkpoint formats
-        if 'model_state_dict' in medsiglip_state:
-            model.load_state_dict(medsiglip_state['model_state_dict'])
-        else:
-            model.load_state_dict(medsiglip_state)
-        
-        # Store ensemble weights for prediction fusion
-        model.ensemble_weights = ensemble_weights
-        
-        model.to(device)
-        model.eval()
-        
-        return model

models/monet_concepts.py

@@ -1,332 +0,0 @@
-# models/monet_concepts.py
-
-import torch
-import numpy as np
-from typing import Dict, List
-from dataclasses import dataclass
-
-@dataclass
-class ConceptScore:
-    """Single MONET concept with score and evidence"""
-    name: str
-    score: float
-    confidence: float
-    description: str
-    clinical_relevance: str  # How this affects diagnosis
-
-class MONETConceptScorer:
-    """
-    MONET concept scoring using your trained metadata patterns
-    Integrates the boosting logic from your ensemble code
-    """
-    
-    # MONET concepts used in your training
-    CONCEPT_DEFINITIONS = {
-        'MONET_ulceration_crust': {
-            'description': 'Ulceration or crusting present',
-            'high_in': ['SCCKA', 'BCC', 'MAL_OTH'],
-            'low_in': ['NV', 'BKL'],
-            'threshold_high': 0.50
-        },
-        'MONET_erythema': {
-            'description': 'Redness or inflammation',
-            'high_in': ['INF', 'BCC', 'SCCKA'],
-            'low_in': ['MEL', 'NV'],
-            'threshold_high': 0.40
-        },
-        'MONET_pigmented': {
-            'description': 'Pigmentation present',
-            'high_in': ['MEL', 'NV', 'BKL'],
-            'low_in': ['BCC', 'SCCKA', 'INF'],
-            'threshold_high': 0.55
-        },
-        'MONET_vasculature_vessels': {
-            'description': 'Vascular structures visible',
-            'high_in': ['VASC', 'BCC'],
-            'low_in': ['MEL', 'NV'],
-            'threshold_high': 0.35
-        },
-        'MONET_hair': {
-            'description': 'Hair follicles present',
-            'high_in': ['NV', 'BKL'],
-            'low_in': ['BCC', 'MEL'],
-            'threshold_high': 0.30
-        },
-        'MONET_gel_water_drop_fluid_dermoscopy_liquid': {
-            'description': 'Gel/fluid artifacts',
-            'high_in': [],
-            'low_in': [],
-            'threshold_high': 0.40
-        },
-        'MONET_skin_markings_pen_ink_purple_pen': {
-            'description': 'Pen markings present',
-            'high_in': [],
-            'low_in': [],
-            'threshold_high': 0.40
-        }
-    }
-    
-    # Class-specific patterns from your metadata boosting
-    CLASS_PATTERNS = {
-        'MAL_OTH': {
-            'sex': 'male',  # 88.9% male
-            'site_preference': 'trunk',
-            'age_range': (60, 80),
-            'key_concepts': {'MONET_ulceration_crust': 0.35}
-        },
-        'INF': {
-            'key_concepts': {
-                'MONET_erythema': 0.42,
-                'MONET_pigmented': (None, 0.30)  # Low pigmentation
-            }
-        },
-        'BEN_OTH': {
-            'site_preference': ['head', 'neck', 'face'],  # 47.7%
-            'key_concepts': {'MONET_pigmented': (0.30, 0.50)}
-        },
-        'DF': {
-            'site_preference': ['lower', 'leg', 'ankle', 'foot'],  # 65.4%
-            'age_range': (40, 65)
-        },
-        'SCCKA': {
-            'age_range': (65, None),
-            'key_concepts': {
-                'MONET_ulceration_crust': 0.50,
-                'MONET_pigmented': (None, 0.15)
-            }
-        },
-        'MEL': {
-            'age_range': (55, None),  # 61.8 years average
-            'key_concepts': {'MONET_pigmented': 0.55}
-        },
-        'NV': {
-            'age_range': (None, 45),  # 42.0 years average
-            'key_concepts': {'MONET_pigmented': 0.55}
-        }
-    }
-    
-    def __init__(self):
-        """Initialize MONET scorer with class patterns"""
-        self.class_names = [
-            'AKIEC', 'BCC', 'BEN_OTH', 'BKL', 'DF', 
-            'INF', 'MAL_OTH', 'MEL', 'NV', 'SCCKA', 'VASC'
-        ]
-    
-    def compute_concept_scores(
-        self,
-        metadata: Dict[str, float]
-    ) -> Dict[str, ConceptScore]:
-        """
-        Compute MONET concept scores from metadata
-        
-        Args:
-            metadata: Dictionary with MONET scores, age, sex, site, etc.
-            
-        Returns:
-            Dictionary of concept scores
-        """
-        concept_scores = {}
-        
-        for concept_name, definition in self.CONCEPT_DEFINITIONS.items():
-            score = metadata.get(concept_name, 0.0)
-            
-            # Determine confidence based on how extreme the score is
-            if score > definition['threshold_high']:
-                confidence = min((score - definition['threshold_high']) / 0.2, 1.0)
-                level = "HIGH"
-            elif score < 0.2:
-                confidence = min((0.2 - score) / 0.2, 1.0)
-                level = "LOW"
-            else:
-                confidence = 0.5
-                level = "MODERATE"
-            
-            # Clinical relevance
-            if level == "HIGH":
-                relevant_classes = definition['high_in']
-                clinical_relevance = f"Supports: {', '.join(relevant_classes)}"
-            elif level == "LOW":
-                excluded_classes = definition['low_in']
-                clinical_relevance = f"Against: {', '.join(excluded_classes)}"
-            else:
-                clinical_relevance = "Non-specific"
-            
-            concept_scores[concept_name] = ConceptScore(
-                name=concept_name.replace('MONET_', '').replace('_', ' ').title(),
-                score=score,
-                confidence=confidence,
-                description=f"{definition['description']} ({level})",
-                clinical_relevance=clinical_relevance
-            )
-        
-        return concept_scores
-    
-    def apply_metadata_boosting(
-        self,
-        probs: np.ndarray,
-        metadata: Dict
-    ) -> np.ndarray:
-        """
-        Apply your metadata boosting logic
-        This is directly from your ensemble optimization code
-        
-        Args:
-            probs: [11] probability array
-            metadata: Dictionary with age, sex, site, MONET scores
-            
-        Returns:
-            boosted_probs: [11] adjusted probabilities
-        """
-        boosted_probs = probs.copy()
-        
-        # 1. MAL_OTH boosting
-        if metadata.get('sex') == 'male':
-            site = str(metadata.get('site', '')).lower()
-            if 'trunk' in site:
-                age = metadata.get('age_approx', 60)
-                ulceration = metadata.get('MONET_ulceration_crust', 0)
-                
-                score = 0
-                score += 3 if metadata.get('sex') == 'male' else 0
-                score += 2 if 'trunk' in site else 0
-                score += 1 if 60 <= age <= 80 else 0
-                score += 2 if ulceration > 0.35 else 0
-                
-                confidence = score / 8.0
-                if confidence > 0.5:
-                    boosted_probs[6] *= (1.0 + confidence)  # MAL_OTH index
-        
-        # 2. INF boosting
-        erythema = metadata.get('MONET_erythema', 0)
-        pigmentation = metadata.get('MONET_pigmented', 0)
-        
-        if erythema > 0.42 and pigmentation < 0.30:
-            confidence = min((erythema - 0.42) / 0.10 + 0.5, 1.0)
-            boosted_probs[5] *= (1.0 + confidence * 0.8)  # INF index
-        
-        # 3. BEN_OTH boosting
-        site = str(metadata.get('site', '')).lower()
-        is_head_neck = any(x in site for x in ['head', 'neck', 'face'])
-        
-        if is_head_neck and 0.30 < pigmentation < 0.50:
-            ulceration = metadata.get('MONET_ulceration_crust', 0)
-            confidence = 0.7 if ulceration < 0.30 else 0.4
-            boosted_probs[2] *= (1.0 + confidence * 0.5)  # BEN_OTH index
-        
-        # 4. DF boosting
-        is_lower_ext = any(x in site for x in ['lower', 'leg', 'ankle', 'foot'])
-        
-        if is_lower_ext:
-            age = metadata.get('age_approx', 60)
-            if 40 <= age <= 65:
-                boosted_probs[4] *= 1.8  # DF index
-            elif 30 <= age <= 75:
-                boosted_probs[4] *= 1.5
-        
-        # 5. SCCKA boosting
-        ulceration = metadata.get('MONET_ulceration_crust', 0)
-        age = metadata.get('age_approx', 60)
-        
-        if ulceration > 0.50 and age >= 65 and pigmentation < 0.15:
-            boosted_probs[9] *= 1.9  # SCCKA index
-        elif ulceration > 0.45 and age >= 60 and pigmentation < 0.20:
-            boosted_probs[9] *= 1.5
-        
-        # 6. MEL vs NV age separation
-        if pigmentation > 0.55:
-            if age >= 55:
-                age_score = min((age - 55) / 20.0, 1.0)
-                boosted_probs[7] *= (1.0 + age_score * 0.5)  # MEL
-                boosted_probs[8] *= (1.0 - age_score * 0.3)  # NV
-            elif age <= 45:
-                age_score = min((45 - age) / 30.0, 1.0)
-                boosted_probs[7] *= (1.0 - age_score * 0.3)  # MEL
-                boosted_probs[8] *= (1.0 + age_score * 0.5)  # NV
-        
-        # 7. Exclusions based on pigmentation/erythema
-        if pigmentation > 0.50:
-            boosted_probs[0] *= 0.7  # AKIEC
-            boosted_probs[1] *= 0.6  # BCC
-            boosted_probs[5] *= 0.5  # INF
-            boosted_probs[9] *= 0.3  # SCCKA
-        
-        if erythema > 0.40:
-            boosted_probs[7] *= 0.7  # MEL
-            boosted_probs[8] *= 0.7  # NV
-        
-        if pigmentation < 0.20:
-            boosted_probs[7] *= 0.5  # MEL
-            boosted_probs[8] *= 0.5  # NV
-        
-        # Renormalize
-        return boosted_probs / boosted_probs.sum()
-    
-    def explain_prediction(
-        self,
-        probs: np.ndarray,
-        concept_scores: Dict[str, ConceptScore],
-        metadata: Dict
-    ) -> str:
-        """
-        Generate natural language explanation
-        
-        Args:
-            probs: Class probabilities
-            concept_scores: MONET concept scores
-            metadata: Clinical metadata
-            
-        Returns:
-            Natural language explanation
-        """
-        predicted_idx = np.argmax(probs)
-        predicted_class = self.class_names[predicted_idx]
-        confidence = probs[predicted_idx]
-        
-        explanation = f"**Primary Diagnosis: {predicted_class}**\n"
-        explanation += f"Confidence: {confidence:.1%}\n\n"
-        
-        # Key MONET features
-        explanation += "**Key Dermoscopic Features:**\n"
-        
-        sorted_concepts = sorted(
-            concept_scores.values(),
-            key=lambda x: x.score * x.confidence,
-            reverse=True
-        )
-        
-        for i, concept in enumerate(sorted_concepts[:5], 1):
-            if concept.score > 0.3 or concept.score < 0.2:
-                explanation += f"{i}. {concept.name}: {concept.score:.2f} - {concept.description}\n"
-                if concept.clinical_relevance != "Non-specific":
-                    explanation += f"   → {concept.clinical_relevance}\n"
-        
-        # Clinical context
-        explanation += "\n**Clinical Context:**\n"
-        if 'age_approx' in metadata:
-            explanation += f"• Age: {metadata['age_approx']} years\n"
-        if 'sex' in metadata:
-            explanation += f"• Sex: {metadata['sex']}\n"
-        if 'site' in metadata:
-            explanation += f"• Location: {metadata['site']}\n"
-        
-        return explanation
-    
-    def get_top_concepts(
-        self,
-        concept_scores: Dict[str, ConceptScore],
-        top_k: int = 5,
-        min_score: float = 0.3
-    ) -> List[ConceptScore]:
-        """Get top-k most important concepts"""
-        filtered = [
-            cs for cs in concept_scores.values() 
-            if cs.score >= min_score or cs.score < 0.2  # High or low
-        ]
-        
-        sorted_concepts = sorted(
-            filtered,
-            key=lambda x: x.score * x.confidence,
-            reverse=True
-        )
-        
-        return sorted_concepts[:top_k]

test_models.py

@@ -1,86 +0,0 @@
-#!/usr/bin/env python3
-"""Test script to verify model loading"""
-
-import torch
-import torch.nn as nn
-import timm
-from transformers import AutoModel, AutoProcessor
-import numpy as np
-
-DEVICE = "cpu"
-print(f"Device: {DEVICE}")
-
-# ConvNeXt model definition (matching checkpoint)
-class ConvNeXtDualEncoder(nn.Module):
-    def __init__(self, model_name="convnext_base.fb_in22k_ft_in1k",
-                 metadata_dim=19, num_classes=11, dropout=0.3):
-        super().__init__()
-        self.backbone = timm.create_model(model_name, pretrained=False, num_classes=0)
-        backbone_dim = self.backbone.num_features
-        self.meta_mlp = nn.Sequential(
-            nn.Linear(metadata_dim, 64), nn.LayerNorm(64), nn.GELU(), nn.Dropout(dropout)
-        )
-        fusion_dim = backbone_dim * 2 + 64
-        self.classifier = nn.Sequential(
-            nn.Linear(fusion_dim, 512), nn.LayerNorm(512), nn.GELU(), nn.Dropout(dropout),
-            nn.Linear(512, 256), nn.LayerNorm(256), nn.GELU(), nn.Dropout(dropout),
-            nn.Linear(256, num_classes)
-        )
-
-    def forward(self, clinical_img, derm_img=None, metadata=None):
-        clinical_features = self.backbone(clinical_img)
-        derm_features = self.backbone(derm_img) if derm_img is not None else clinical_features
-        if metadata is not None:
-            meta_features = self.meta_mlp(metadata)
-        else:
-            meta_features = torch.zeros(clinical_features.size(0), 64, device=clinical_features.device)
-        fused = torch.cat([clinical_features, derm_features, meta_features], dim=1)
-        return self.classifier(fused)
-
-
-# MedSigLIP model definition
-class MedSigLIPClassifier(nn.Module):
-    def __init__(self, num_classes=11, model_name="google/siglip-base-patch16-384"):
-        super().__init__()
-        self.siglip = AutoModel.from_pretrained(model_name)
-        self.processor = AutoProcessor.from_pretrained(model_name)
-        hidden_dim = self.siglip.config.vision_config.hidden_size
-        self.classifier = nn.Sequential(
-            nn.Linear(hidden_dim, 512), nn.LayerNorm(512), nn.GELU(), nn.Dropout(0.3),
-            nn.Linear(512, num_classes)
-        )
-        for param in self.siglip.parameters():
-            param.requires_grad = False
-
-    def forward(self, pixel_values):
-        vision_outputs = self.siglip.vision_model(pixel_values=pixel_values)
-        pooled_features = vision_outputs.pooler_output
-        return self.classifier(pooled_features)
-
-
-if __name__ == "__main__":
-    print("\n[1/2] Loading ConvNeXt...")
-    convnext_model = ConvNeXtDualEncoder()
-    ckpt = torch.load("models/seed42_fold0.pt", map_location=DEVICE, weights_only=False)
-    convnext_model.load_state_dict(ckpt)
-    convnext_model.eval()
-    print("   ConvNeXt loaded!")
-
-    print("\n[2/2] Loading MedSigLIP...")
-    medsiglip_model = MedSigLIPClassifier()
-    medsiglip_model.eval()
-    print("   MedSigLIP loaded!")
-
-    # Quick inference test
-    print("\nTesting inference...")
-    dummy_img = torch.randn(1, 3, 384, 384)
-    with torch.no_grad():
-        convnext_out = convnext_model(dummy_img)
-        print(f"   ConvNeXt output: {convnext_out.shape}")
-
-        dummy_pil = np.random.randint(0, 255, (384, 384, 3), dtype=np.uint8)
-        siglip_input = medsiglip_model.processor(images=[dummy_pil], return_tensors="pt")
-        siglip_out = medsiglip_model(siglip_input["pixel_values"])
-        print(f"   MedSigLIP output: {siglip_out.shape}")
-
-    print("\nAll tests passed!")