Simplify Gradio demo to fix schema bug

scripts/demo_gradio.py

@@ -1,587 +1,140 @@
-"""
-Minimal Gradio demo for the LexiMind multitask model.
-Shows raw model outputs without any post-processing tricks.
-"""
+"""Minimal Gradio demo for LexiMind multitask model."""
 
 from __future__ import annotations
 
 import json
-import re
 import sys
-from datetime import datetime
 from pathlib import Path
-from tempfile import NamedTemporaryFile
-from typing import Iterable, Sequence
 
 import gradio as gr
-import matplotlib.pyplot as plt
-import pandas as pd
-import seaborn as sns
-import torch
-from gradio.themes import Soft
-from matplotlib.figure import Figure
 
-# Make local packages importable when running the script directly
 SCRIPT_DIR = Path(__file__).resolve().parent
-
-
-def guess_project_root(script_dir: Path) -> Path:
-    """Attempt to locate the LexiMind repo root even when deployed under /app."""
-    markers = ("pyproject.toml", "setup.py", "README.md")
-    candidates = [script_dir]
-    candidates.extend(script_dir.parents)
-    candidates.extend(
-        [
-            script_dir / "LexiMind",
-            script_dir.parent / "LexiMind",
-            Path("/LexiMind"),
-        ]
-    )
-
-    seen: set[Path] = set()
-    for candidate in candidates:
-        if candidate in seen:
-            continue
-        seen.add(candidate)
-        if any((candidate / marker).exists() for marker in markers):
-            return candidate
-
-    return script_dir.parent
-
-
-PROJECT_ROOT = guess_project_root(SCRIPT_DIR)
+PROJECT_ROOT = SCRIPT_DIR.parent
 if str(PROJECT_ROOT) not in sys.path:
     sys.path.insert(0, str(PROJECT_ROOT))
 
-OUTPUTS_DIR = PROJECT_ROOT / "outputs"
-EVAL_REPORT_PATH = OUTPUTS_DIR / "evaluation_report.json"
-CONFUSION_MATRIX_PATH = OUTPUTS_DIR / "topic_confusion_matrix.png"
-
 from huggingface_hub import hf_hub_download
 
 from src.inference.factory import create_inference_pipeline
-from src.inference.pipeline import EmotionPrediction, InferencePipeline, TopicPrediction
 from src.utils.logging import configure_logging, get_logger
 
 configure_logging()
 logger = get_logger(__name__)
 
-_pipeline: InferencePipeline | None = None
+OUTPUTS_DIR = PROJECT_ROOT / "outputs"
+EVAL_REPORT_PATH = OUTPUTS_DIR / "evaluation_report.json"
 
-VISUALIZATION_DIR = OUTPUTS_DIR
-VISUALIZATION_ASSETS: list[tuple[str, str]] = [
-    ("attention_visualization.png", "Attention weights (single head)"),
-    ("multihead_attention_visualization.png", "Multi-head attention comparison"),
-    ("single_vs_multihead.png", "Single vs multi-head attention"),
-    ("positional_encoding_heatmap.png", "Positional encoding heatmap"),
-]
+_pipeline = None
 
 
-def get_pipeline() -> InferencePipeline:
+def get_pipeline():
     global _pipeline
     if _pipeline is None:
-        logger.info("Loading inference pipeline ...")
-
-        # Download checkpoint if not found locally
         checkpoint_path = Path("checkpoints/best.pt")
         if not checkpoint_path.exists():
-            logger.info("Checkpoint not found locally. Downloading from Hugging Face Hub...")
-            try:
-                # Ensure checkpoints directory exists
-                checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
-
-                # Download from the model repository
-                # NOTE: Replace 'OliverPerrin/LexiMind-Model' with your actual model repo ID
-                downloaded_path = hf_hub_download(
-                    repo_id="OliverPerrin/LexiMind-Model",
-                    filename="best.pt",
-                    local_dir="checkpoints",
-                    local_dir_use_symlinks=False,
-                )
-                logger.info(f"Checkpoint downloaded to {downloaded_path}")
-            except Exception as e:
-                logger.error(f"Failed to download checkpoint: {e}")
-                # Fallback or re-raise will happen in create_inference_pipeline
-
+            checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
+            hf_hub_download(
+                repo_id="OliverPerrin/LexiMind-Model",
+                filename="best.pt",
+                local_dir="checkpoints",
+                local_dir_use_symlinks=False,
+            )
         _pipeline, _ = create_inference_pipeline(
             tokenizer_dir="artifacts/hf_tokenizer/",
             checkpoint_path="checkpoints/best.pt",
             labels_path="artifacts/labels.json",
         )
-        logger.info("Pipeline loaded")
     return _pipeline
 
 
-def count_tokens(text: str) -> str:
-    if not text:
-        return "Tokens: 0"
-    try:
-        pipeline = get_pipeline()
-        return f"Tokens: {len(pipeline.tokenizer.encode(text))}"
-    except Exception as exc:  # pragma: no cover - surfaced in UI
-        logger.error("Token counting failed: %s", exc, exc_info=True)
-        return "Token count unavailable"
-
-
-def predict(text: str):
+def analyze(text: str) -> str:
+    """Run all three tasks and return results as formatted text."""
     if not text or not text.strip():
-        return (
-            "Please enter text to analyze.",
-            None,
-            "No topic prediction available.",
-            None,
-        )
+        return "Please enter some text to analyze."
 
     try:
-        pipeline = get_pipeline()
-        # Fixed max length for simplicity
-        max_len = 128
-        logger.info("Generating summary with max length %s", max_len)
+        pipe = get_pipeline()
 
-        summary = pipeline.summarize([text], max_length=max_len)[0].strip()
-        # Use a higher threshold to filter out weak/wrong predictions on out-of-domain text
-        emotions = pipeline.predict_emotions([text], threshold=0.6)[0]
-        topic = pipeline.predict_topics([text])[0]
+        # Summarization
+        summary = pipe.summarize([text], max_length=128)[0].strip() or "(empty)"
 
-        fallback_summary = None
-        summary_notice = ""
-        summary_source = summary
-        if not summary:
-            fallback_summary = generate_fallback_summary(text)
-            summary_source = fallback_summary
-            summary_notice = (
-                '<p style="color: #b45309; margin-top: 8px;">'
-                "Model returned an empty summary, so a simple extractive fallback is shown instead."
-                "</p>"
+        # Emotion detection
+        emotions = pipe.predict_emotions([text], threshold=0.5)[0]
+        if emotions.labels:
+            emotion_str = ", ".join(
+                f"{lbl} ({score:.1%})"
+                for lbl, score in zip(emotions.labels, emotions.scores, strict=True)
             )
-
-        summary_html = format_summary(text, summary_source, notice=summary_notice)
-        emotion_plot = create_emotion_plot(emotions)
-        topic_markdown = format_topic(topic)
-        heatmap_source = summary if summary else fallback_summary
-        if heatmap_source:
-            attention_fig = create_attention_heatmap(text, heatmap_source, pipeline)
         else:
-            attention_fig = render_message_figure(
-                "Attention heatmap unavailable: summary was empty."
-            )
-
-        return summary_html, emotion_plot, topic_markdown, attention_fig
-
-    except Exception as exc:  # pragma: no cover - surfaced in UI
-        logger.error("Prediction error: %s", exc, exc_info=True)
-        return "Prediction failed. Check logs for details.", None, "Error", None
-
-
-def format_summary(original: str, summary: str, *, notice: str = "") -> str:
-    if not summary:
-        summary = "(Model returned an empty summary. Consider retraining the summarization head.)"
-
-    return f"""
-    <div style=\"padding: 12px; border-radius: 6px; background-color: #fafafa; color: #222;\">
-        <h3 style=\"margin-top: 0; color: #222;\">Original Text</h3>
-        <p style=\"background-color: #f0f0f0; padding: 10px; border-radius: 4px; white-space: pre-wrap; color: #222;\">
-            {original}
-        </p>
-        <h3 style=\"color: #222;\">Summary</h3>
-        <p style=\"background-color: #e6f3ff; padding: 10px; border-radius: 4px; white-space: pre-wrap; color: #111;\">
-            {summary}
-        </p>
-        {notice}
-        <p style=\"margin-top: 12px; color: #6b7280; font-size: 0.9rem;\">
-            Outputs are shown exactly as produced by the checkpoint.
-        </p>
-    </div>
-    """.strip()
-
-
-def create_emotion_plot(emotions: EmotionPrediction) -> Figure | None:
-    if not emotions.labels:
-        return render_message_figure("No emotions cleared the model threshold.")
-
-    df = pd.DataFrame({"Emotion": emotions.labels, "Probability": emotions.scores}).sort_values(
-        "Probability", ascending=True
-    )
-    fig, ax = plt.subplots(figsize=(6, 4))
-    colors = sns.color_palette("crest", len(df))
-    bars = ax.barh(df["Emotion"], df["Probability"], color=colors)
-    ax.set_xlabel("Probability")
-    ax.set_title("Emotion Scores")
-    ax.set_xlim(0, 1)
-    for bar in bars:
-        width = bar.get_width()
-        ax.text(width + 0.02, bar.get_y() + bar.get_height() / 2, f"{width:.2%}", va="center")
-    plt.tight_layout()
-    return fig
-
-
-def format_topic(topic: TopicPrediction | dict[str, float | str]) -> str:
-    if isinstance(topic, TopicPrediction):
-        label = topic.label
-        confidence = topic.confidence
-    else:
-        label = str(topic.get("label", "Unknown"))
-        confidence = float(topic.get("score", 0.0))
-    return f"""
-    ### Predicted Topic
+            emotion_str = "No strong emotions detected"
 
-    **{label}**
+        # Topic classification
+        topic = pipe.predict_topics([text])[0]
+        topic_str = f"{topic.label} ({topic.confidence:.1%})"
 
-    Confidence: {confidence:.2%}
-    """.strip()
-
-
-def _clean_tokens(tokens: Iterable[str]) -> list[str]:
-    cleaned: list[str] = []
-    for token in tokens:
-        item = token.replace("Ġ", " ").replace("▁", " ")
-        cleaned.append(item.strip() if item.strip() else token)
-    return cleaned
-
-
-def create_attention_heatmap(text: str, summary: str, pipeline: InferencePipeline) -> Figure | None:
-    try:
-        batch = pipeline.preprocessor.batch_encode([text])
-        batch = pipeline._batch_to_device(batch)
-        src_ids = batch.input_ids
-        src_mask = batch.attention_mask
-        encoder_mask = (
-            src_mask.unsqueeze(1) & src_mask.unsqueeze(2) if src_mask is not None else None
-        )
-
-        with torch.inference_mode():
-            memory = pipeline.model.encoder(src_ids, mask=encoder_mask)  # type: ignore
-            target_enc = pipeline.tokenizer.batch_encode([summary])
-            target_ids = target_enc["input_ids"].to(pipeline.device)
-            target_mask = target_enc["attention_mask"].to(pipeline.device)
-            target_len = int(target_mask.sum().item())
-            decoder_inputs = pipeline.tokenizer.prepare_decoder_inputs(target_ids)
-            decoder_inputs = decoder_inputs[:, :target_len].to(pipeline.device)
-            target_ids = target_ids[:, :target_len]
-            memory_mask = src_mask.to(pipeline.device) if src_mask is not None else None
-            _, attn_list = pipeline.model.decoder(  # type: ignore
-                decoder_inputs,
-                memory,
-                memory_mask=memory_mask,
-                collect_attn=True,
-            )
-
-        if not attn_list:
-            return None
-        cross_attn = attn_list[-1]["cross"]
-        attn_matrix = cross_attn.mean(dim=1)[0].detach().cpu().numpy()
-        source_len = batch.lengths[0]
-        attn_matrix = attn_matrix[:target_len, :source_len]
-
-        source_ids = src_ids[0, :source_len].tolist()
-        target_id_list = target_ids[0].tolist()
-
-        special_ids = {
-            pipeline.tokenizer.pad_token_id,
-            pipeline.tokenizer.bos_token_id,
-            pipeline.tokenizer.eos_token_id,
-        }
-        keep_indices = [
-            idx for idx, token_id in enumerate(target_id_list) if token_id not in special_ids
-        ]
-        if not keep_indices:
-            return None
+        return f"""## Summary
+{summary}
 
-        pruned_matrix = attn_matrix[keep_indices, :]
-        tokenizer_impl = pipeline.tokenizer.tokenizer
-        convert_tokens = getattr(tokenizer_impl, "convert_ids_to_tokens", None)
-        if convert_tokens is None:
-            return None
+## Detected Emotions
+{emotion_str}
 
-        summary_tokens_raw = convert_tokens([target_id_list[idx] for idx in keep_indices])
-        source_tokens_raw = convert_tokens(source_ids)
-
-        summary_tokens = _clean_tokens(summary_tokens_raw)
-        source_tokens = _clean_tokens(source_tokens_raw)
-
-        # Cap the visualization to prevent massive heatmaps
-        max_tokens = 40
-        if len(summary_tokens) > max_tokens:
-            summary_tokens = summary_tokens[:max_tokens]
-            pruned_matrix = pruned_matrix[:max_tokens, :]
-        if len(source_tokens) > max_tokens:
-            source_tokens = source_tokens[:max_tokens]
-            pruned_matrix = pruned_matrix[:, :max_tokens]
-
-        height = max(4.0, 0.3 * len(summary_tokens))
-        width = max(6.0, 0.3 * len(source_tokens))
-        fig, ax = plt.subplots(figsize=(width, height))
-        sns.heatmap(
-            pruned_matrix,
-            cmap="mako",
-            xticklabels=source_tokens,
-            yticklabels=summary_tokens,
-            ax=ax,
-            cbar_kws={"label": "Attention"},
-        )
-        ax.set_xlabel("Input Tokens")
-        ax.set_ylabel("Summary Tokens")
-        ax.set_title("Cross-Attention (decoder last layer)")
-        ax.tick_params(axis="x", rotation=90)
-        ax.tick_params(axis="y", rotation=0)
-        fig.tight_layout()
-        return fig
-
-    except Exception as exc:
-        logger.error("Unable to build attention heatmap: %s", exc, exc_info=True)
-        return render_message_figure("Unable to render attention heatmap for this example.")
-
-
-def render_message_figure(message: str) -> Figure:
-    fig, ax = plt.subplots(figsize=(6, 2))
-    ax.axis("off")
-    ax.text(0.5, 0.5, message, ha="center", va="center", wrap=True)
-    fig.tight_layout()
-    return fig
-
-
-def prepare_download(
-    text: str,
-    summary: str,
-    emotions: EmotionPrediction | dict[str, Sequence[float] | Sequence[str]],
-    topic: TopicPrediction | dict[str, float | str],
-    *,
-    neural_summary: str | None = None,
-    fallback_summary: str | None = None,
-) -> str:
-    if isinstance(emotions, EmotionPrediction):
-        emotion_payload = {
-            "labels": list(emotions.labels),
-            "scores": list(emotions.scores),
-        }
-    else:
-        emotion_payload = {
-            "labels": list(emotions.get("labels", [])),
-            "scores": list(emotions.get("scores", [])),
-        }
-
-    if isinstance(topic, TopicPrediction):
-        topic_payload = {"label": topic.label, "confidence": topic.confidence}
-    else:
-        topic_payload = {
-            "label": str(topic.get("label", topic.get("topic", "Unknown"))),
-            "confidence": float(topic.get("confidence", topic.get("score", 0.0))),
-        }
-
-    payload = {
-        "original_text": text,
-        "summary": summary,
-        "neural_summary": neural_summary,
-        "fallback_summary": fallback_summary,
-        "emotions": emotion_payload,
-        "topic": topic_payload,
-    }
-
-    with NamedTemporaryFile("w", delete=False, suffix=".json", encoding="utf-8") as handle:
-        json.dump(payload, handle, ensure_ascii=False, indent=2)
-        return handle.name
-
-
-def load_visualization_gallery() -> tuple[list[str], str]:
-    """Collect visualization images produced by model tests."""
-    items: list[str] = []
-    missing: list[str] = []
-    for filename, _label in VISUALIZATION_ASSETS:
-        path = VISUALIZATION_DIR / filename
-        if path.exists():
-            items.append(str(path))
-        else:
-            missing.append(filename)
-
-    if items:
-        status = f"Loaded {len(items)} visualization(s) from {VISUALIZATION_DIR}."
-    else:
-        status = (
-            "No visualization PNGs found in the outputs/ directory. "
-            "Ensure tests/test_models/* have produced the PNGs and that they are available on this host."
-        )
-
-    if missing:
-        status += f" Missing files: {', '.join(missing)}."
-
-    return items, status
-
-
-def generate_fallback_summary(text: str, max_chars: int = 320) -> str:
-    content = text.strip()
-    if not content:
-        return "(Input text was empty.)"
-
-    sentences = re.split(r"(?<=[.!?])\s+", content)
-    fragments: list[str] = []
-    total = 0
-    for sentence in sentences:
-        if not sentence:
-            continue
-        candidate = sentence if sentence.endswith((".", "!", "?")) else f"{sentence}."
-        if total + len(candidate) > max_chars and fragments:
-            break
-        fragments.append(candidate)
-        total += len(candidate)
-
-    if not fragments:
-        return content[:max_chars]
-    return " ".join(fragments)
+## Topic
+{topic_str}
+"""
+    except Exception as e:
+        logger.error("Analysis failed: %s", e, exc_info=True)
+        return f"Error: {e}"
 
 
-def load_metrics_report_as_markdown() -> tuple[str, str, str | None, str]:
-    """Load metrics and return as Markdown strings to avoid Gradio schema issues."""
+def get_metrics() -> str:
+    """Load evaluation metrics as markdown."""
     if not EVAL_REPORT_PATH.exists():
-        error_msg = (
-            f"Evaluation report not found at {EVAL_REPORT_PATH}. Run scripts/evaluate.py first."
-        )
-        return error_msg, "", None, error_msg
+        return "No evaluation report found. Run `scripts/evaluate.py` first."
 
     try:
-        with EVAL_REPORT_PATH.open("r", encoding="utf-8") as handle:
-            report = json.load(handle)
-    except Exception as exc:
-        logger.error("Failed to read evaluation report: %s", exc, exc_info=True)
-        error_msg = f"Error loading report: {exc}"
-        return error_msg, "", None, error_msg
-
-    # Build overall metrics markdown table
-    summary_md = """| Task | Metric | Value |
-                    |------|--------|-------|
-                    | Summarization | ROUGE-Like | {:.4f} |
-                    | Summarization | BLEU | {:.4f} |
-                    | Emotion | F1 (Macro) | {:.4f} |
-                    | Topic | Accuracy | {:.4f} |""".format(
-        report["summarization"]["rouge_like"],
-        report["summarization"]["bleu"],
-        report["emotion"]["f1_macro"],
-        report["topic"]["accuracy"],
-    )
-
-    # Build topic classification report markdown table
-    topic_report = report["topic"]["classification_report"]
-    topic_lines = [
-        "| Label | Precision | Recall | F1-Score | Support |",
-        "|-------|-----------|--------|----------|---------|",
-    ]
-    for label, metrics in topic_report.items():
-        if isinstance(metrics, dict) and "precision" in metrics:
-            topic_lines.append(
-                f"| {label} | {metrics['precision']:.4f} | {metrics['recall']:.4f} | {metrics['f1-score']:.4f} | {int(metrics.get('support', 0))} |"
-            )
-    topic_md = "\n".join(topic_lines)
-
-    # Confusion Matrix
-    cm_image = str(CONFUSION_MATRIX_PATH) if CONFUSION_MATRIX_PATH.exists() else None
-
-    # Metadata
-    meta_str = f"Split: {report.get('split', 'unknown')}\nLast updated: {datetime.fromtimestamp(EVAL_REPORT_PATH.stat().st_mtime).isoformat()}"
-
-    return summary_md, topic_md, cm_image, meta_str
-
-
-SAMPLE_TEXT = (
-    "Artificial intelligence is rapidly transforming the technology landscape. "
-    "Machine learning algorithms are now capable of processing vast amounts of data, "
-    "identifying patterns, and making predictions with unprecedented accuracy. "
-    "From healthcare diagnostics to financial forecasting, AI applications are "
-    "revolutionizing industries worldwide. However, ethical considerations around "
-    "privacy, bias, and transparency remain critical challenges that must be addressed "
-    "as these technologies continue to evolve."
-)
-
-
-def create_interface() -> gr.Blocks:
-    with gr.Blocks(title="LexiMind Demo", theme=Soft()) as demo:
-        gr.Markdown(
-            """
-            # LexiMind NLP Demo
-
-            This demo streams the raw outputs from the saved LexiMind checkpoint.
-            Results may be noisy; retraining is recommended for production use.
-            """
-        )
-
-        _, initial_visual_status = load_visualization_gallery()
-        summary_md, topic_md, cm_image, metrics_meta = load_metrics_report_as_markdown()
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                input_text = gr.Textbox(
-                    label="Input Text",
-                    lines=10,
-                    value=SAMPLE_TEXT,
-                    placeholder="Paste or type your text here...",
+        with open(EVAL_REPORT_PATH) as f:
+            r = json.load(f)
+
+        lines = [
+            "## Model Performance\n",
+            "| Task | Metric | Score |",
+            "|------|--------|-------|",
+            f"| Summarization | ROUGE-Like | {r['summarization']['rouge_like']:.4f} |",
+            f"| Summarization | BLEU | {r['summarization']['bleu']:.4f} |",
+            f"| Emotion | F1 Macro | {r['emotion']['f1_macro']:.4f} |",
+            f"| Topic | Accuracy | {r['topic']['accuracy']:.4f} |",
+            "",
+            "### Topic Classification Details\n",
+            "| Label | Precision | Recall | F1 |",
+            "|-------|-----------|--------|-----|",
+        ]
+        for k, v in r["topic"]["classification_report"].items():
+            if isinstance(v, dict) and "precision" in v:
+                lines.append(
+                    f"| {k} | {v['precision']:.3f} | {v['recall']:.3f} | {v['f1-score']:.3f} |"
                 )
-                token_box = gr.Textbox(label="Token Count", value="Tokens: 0", interactive=False)
-                analyze_btn = gr.Button("Run Analysis", variant="primary")
 
-            with gr.Column(scale=2):
-                with gr.Tabs():
-                    with gr.TabItem("Summary"):
-                        summary_output = gr.HTML(label="Summary")
-                    with gr.TabItem("Emotions"):
-                        emotion_output = gr.Plot(label="Emotion Probabilities")
-                    with gr.TabItem("Topic"):
-                        topic_output = gr.Markdown(label="Topic Prediction")
-                    with gr.TabItem("Attention"):
-                        attention_output = gr.Plot(label="Attention Heatmap")
-                        gr.Markdown("*Shows decoder attention if a summary is available.*")
-                    with gr.TabItem("Model Performance"):
-                        gr.Markdown("### Overall Metrics")
-                        metrics_table = gr.Markdown(value=summary_md)
-                        gr.Markdown("### Topic Classification Report")
-                        topic_table = gr.Markdown(value=topic_md)
-                        gr.Markdown("### Topic Confusion Matrix")
-                        cm_output = gr.Image(value=cm_image, label="Confusion Matrix")
-                        gr.Markdown("### Metadata")
-                        metrics_meta_text = gr.Textbox(
-                            value=metrics_meta,
-                            label="Info",
-                            interactive=False,
-                            lines=2,
-                        )
-                        refresh_metrics = gr.Button("Refresh Metrics")
+        return "\n".join(lines)
+    except Exception as e:
+        return f"Error loading metrics: {e}"
 
-                    with gr.TabItem("Model Visuals"):
-                        gr.Markdown(
-                            "These PNGs come from the visualization-focused tests in `tests/test_models` and are consumed as-is."
-                        )
-                        gr.Markdown(initial_visual_status)
 
-        input_text.change(fn=count_tokens, inputs=[input_text], outputs=[token_box])
-        analyze_btn.click(
-            fn=predict,
-            inputs=[input_text],
-            outputs=[summary_output, emotion_output, topic_output, attention_output],
-        )
-        refresh_metrics.click(
-            fn=load_metrics_report_as_markdown,
-            inputs=None,
-            outputs=[metrics_table, topic_table, cm_output, metrics_meta_text],
-        )
-        return demo
+SAMPLE = """Artificial intelligence is rapidly transforming technology. Machine learning algorithms process vast amounts of data, identifying patterns with unprecedented accuracy. From healthcare to finance, AI is revolutionizing industries worldwide. However, ethical considerations around privacy and bias remain critical challenges."""
 
+with gr.Blocks(title="LexiMind Demo") as demo:
+    gr.Markdown(
+        "# LexiMind NLP Demo\nMulti-task model: summarization, emotion detection, topic classification."
+    )
 
-demo = create_interface()
-app = demo
+    with gr.Tab("Analyze"):
+        text_input = gr.Textbox(label="Input Text", lines=6, value=SAMPLE)
+        analyze_btn = gr.Button("Analyze", variant="primary")
+        output = gr.Markdown(label="Results")
+        analyze_btn.click(fn=analyze, inputs=text_input, outputs=output)
 
+    with gr.Tab("Metrics"):
+        gr.Markdown(get_metrics())
 
 if __name__ == "__main__":
-    import os
-
-    # On HuggingFace Spaces, share must be False (they handle routing)
-    # but we need to ensure server binds correctly
-    is_hf_space = os.environ.get("SPACE_ID") is not None
-
-    try:
-        get_pipeline()
-        demo.queue().launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,
-            allowed_paths=[str(OUTPUTS_DIR)],
-        )
-    except Exception as exc:  # pragma: no cover - surfaced in console
-        logger.error("Failed to launch demo: %s", exc, exc_info=True)
-        raise
+    get_pipeline()  # Pre-load
+    demo.launch(server_name="0.0.0.0", server_port=7860)