made it gradio compatible

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 humaninloop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,13 +1,130 @@
+# 🧠 MADGuard AI Explorer
+
+A diagnostic Gradio tool to simulate feedback loops in Retrieval-Augmented Generation (RAG) pipelines and detect **Model Autophagy Disorder (MAD)** risks.
+
+---
+
+## 🛠️ Tool Description
+
+- Toggle between **real** and **synthetic** input sources
+- Visualize pipeline feedback loops with **Graphviz**
+- Analyze training data via:
+  - Type-Token Ratio (TTR)
+  - Cosine Similarity
+  - Composite MAD Risk Score
+
+---
+
+## 🚀 Run It Locally
+
+```bash
+git clone <your-repo-url>
+cd madguard
+pip install -r requirements.txt
+python app.py
+```
+
+Then open [http://127.0.0.1:7860](http://127.0.0.1:7860) in your browser.
+
+---
+
+## 🌐 Deploy on Hugging Face Spaces
+
+1. Create a new Space (select **Gradio** as the SDK)
+2. Upload:
+   - `app.py`
+   - `requirements.txt`
+   - All files in the `visuals/` folder
+3. Hugging Face builds the app and gives you a public URL
+
+---
+
+<details>
+<summary>📚 Research Background</summary>
+
+### 📄 Self-consuming LLMs: How and When Models Feed Themselves – Santurkar et al., 2023
+
+This paper introduces and explores **Model Autophagy Disorder (MAD)** — showing that large language models trained on their own outputs tend to lose performance and accumulate error over time.
+
+**MADGuard implements several of the paper’s proposed detection strategies:**
+
+| Research Recommendation                     | MADGuard Implementation                   |
+| ------------------------------------------- | ----------------------------------------- |
+| Lexical redundancy analysis                 | ✅ via Type-Token Ratio (TTR)             |
+| Embedding-based similarity scoring          | ✅ via SentenceTransformers + cosine      |
+| Warning system for feedback loop risk       | ✅ risk score (Low / Medium / High)       |
+| Distinguishing real vs. synthetic inputs    | ❌ not implemented (user-controlled only) |
+| Multi-round retraining degradation tracking | ❌ not yet supported                      |
+
+> “MADGuard AI Explorer is inspired by key findings from this research, aligning with early warnings and pipeline hygiene practices recommended in their work.”
+
+📎 [Read Full Paper on arXiv](https://arxiv.org/abs/2307.01850)
+
+</details>
+
 ---
-title: MadGuard
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.0.1
-app_file: app.py
-pinned: false
-license: mit
+
+<details>
+<summary>👥 Who Is It For?</summary>
+
+- **AI/ML Engineers**: Prevent model collapse due to training on synthetic outputs
+- **MLOps Professionals**: Pre-retraining diagnostics
+- **AI Researchers**: Study model feedback loops
+- **Responsible AI Teams**: Audit data pipelines for ethical AI
+
+### Why Use It?
+
+- Avoid data contamination
+- Ensure model freshness
+- Support data-centric decisions
+- Provide audit-ready diagnostics
+
+</details>
+
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+<details>
+<summary>🧱 Limitations & Future Plans</summary>
+
+### 🔸 Current Limitations
+
+| Area                | Missing Element                           |
+| ------------------- | ----------------------------------------- |
+| Multi-batch Uploads | No history or comparative dataset support |
+| Real/Synthetic Tag  | No auto-tagging or provenance logging     |
+| Visual Analytics    | No charts, timelines, or embeddings view  |
+| Custom Thresholds   | Fixed MAD score weightings                |
+| Provenance Tracking | No metadata or source history logging     |
+
+### 🔮 Future Plans
+
+- 📊 Batch evaluations with historical trendlines
+- 🧠 RAG framework integration (e.g., LangChain)
+- 🧩 Live evaluation API endpoint
+- 🔒 Source tracking and audit trails
+- 🧾 Exportable audit/compliance reports
+
+</details>
+
+---
+
+<details>
+<summary>📄 More Details</summary>
+
+### 🔍 Features Recap
+
+- Simulates feedback loops in RAG pipelines
+- Visualizes flow using Graphviz
+- Accepts `.csv` or `.json` data
+- Calculates TTR, cosine similarity, MAD score
+- Classifies risk (Low / Medium / High)
+- Offers human-readable suggestions
+- Based on: [Santurkar et al., 2023 – arXiv:2307.01850](https://arxiv.org/abs/2307.01850)
+
+### 📜 License
+
+MIT License (see [LICENSE](LICENSE))
+
+</details>
+
+---

app.py

@@ -1,64 +1,264 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+import nltk
+import pandas as pd
+from nltk.tokenize import TreebankWordTokenizer
+from sklearn.metrics.pairwise import cosine_similarity
+from sentence_transformers import SentenceTransformer
+import graphviz
+from typing import Tuple, Optional
+from visuals.score_card import render_score_card  # Updated import
+from visuals.layout import (
+    render_page_header,
+    render_core_reference,
+    render_pipeline,
+    render_pipeline_graph,
+    render_pipeline_warning,
+    render_strategy_alignment,
+)  # Updated import
 
+# Ensure NLTK data is downloaded
+try:
+    nltk.download("punkt", quiet=True)
+except Exception as e:
+    print(f"Error downloading NLTK data: {e}")
 
+# Load SentenceTransformer model
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+
+def calculate_ttr(text: str) -> float:
+    """Calculates Type-Token Ratio (TTR) for lexical diversity."""
+    if not text:
+        return 0.0
+    words = text.split()
+    unique_words = set(words)
+    return len(unique_words) / len(words) if words else 0.0
+
+
+def calculate_similarity(text1: str, text2: str) -> float:
+    """Calculates cosine similarity between two texts."""
+    embeddings = model.encode([text1, text2])
+    return cosine_similarity([embeddings[0]], [embeddings[1]])[0][0]
+
+
+def calculate_mad_score(ttr: float, similarity: float) -> float:
+    """Calculates the MAD score."""
+    return 0.3 * (1 - ttr) + 0.7 * similarity
+
+
+def get_risk_level(mad_score: float) -> str:
+    """Determines the risk level based on the MAD score."""
+    if mad_score > 0.7:
+        return "High"
+    elif 0.4 <= mad_score <= 0.7:
+        return "Medium"
+    else:
+        return "Low"
+
+
+def process_data(file_obj, model_col: str, train_col: str, data_source: str) -> Tuple[
+    Optional[str],
+    Optional[bytes],
+    Optional[str],
+    Optional[str],
+    Optional[float],
+    Optional[float],
+    Optional[float],
+]:
+    """Processes the uploaded file and calculates metrics."""
+    try:
+        if not file_obj:
+            return "Error: No file uploaded.", None, None, None, None, None, None
+
+        file_path = file_obj.name
+        if file_path.endswith(".csv"):
+            df = pd.read_csv(file_path)
+        elif file_path.endswith(".json"):
+            df = pd.read_json(file_path)
+        else:
+            return (
+                "Error: Invalid file type. Please upload a CSV or JSON file.",
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            )
+
+        if model_col not in df.columns or train_col not in df.columns:
+            return (
+                "Error: Selected columns not found in the file.",
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            )
+
+        output_text = " ".join(df[model_col].astype(str))
+        train_text = " ".join(df[train_col].astype(str))
+
+        ttr_output = calculate_ttr(output_text)
+        ttr_train = calculate_ttr(train_text)
+        similarity = calculate_similarity(output_text, train_text)
+        mad_score = calculate_mad_score(ttr_output, similarity)
+        risk_level = get_risk_level(mad_score)
+
+        summary, details, explanation = render_score_card(
+            ttr_output, ttr_train, similarity, mad_score, risk_level
+        )
+        evaluation_markdown = summary + details + explanation
+
+        return (
+            None,  # No error
+            render_pipeline_graph(data_source),
+            df.head().to_markdown(index=False, numalign="left", stralign="left"),
+            evaluation_markdown,
+            ttr_output,
+            ttr_train,
+            similarity,
+        )
+
+    except Exception as e:
+        return f"An error occurred: {str(e)}", None, None, None, None, None, None
+
+
+def update_dropdowns(file_obj) -> Tuple[list, str]:
+    """Updates dropdown choices based on the uploaded file."""
+    if not file_obj:
+        return [], "No file uploaded."
+
+    file_path = file_obj.name
+    try:
+        if file_path.endswith(".csv"):
+            df = pd.read_csv(file_path)
+        elif file_path.endswith(".json"):
+            df = pd.read_json(file_path)
+        else:
+            return [], "Invalid file type."
+        columns = df.columns.tolist()
+        preview = df.head().to_markdown(index=False, numalign="left", stralign="left")
+        return columns, preview
+    except Exception as e:
+        return [], f"Error reading file: {e}"
+
+
+def main_interface():
+    css = """
+    .gradio-container {
+        background: linear-gradient(-45deg, #e0f7fa, #e1f5fe, #f1f8e9, #fff3e0);
+        background-size: 400% 400%;
+        animation: oceanWaves 20s ease infinite;
+    }
+    @keyframes oceanWaves {
+        0% { background-position: 0% 50%; }
+        50% { background-position: 100% 50%; }
+        100% { background-position: 0% 50%; }
+    }
+    """
+
+    with gr.Blocks(css=css, title="MADGuard AI Explorer") as interface:
+        gr.HTML(render_page_header())
+
+        with gr.Accordion("📚 Research Reference: arXiv:2307.01850", open=False):
+            gr.HTML(render_core_reference())
+
+        gr.Markdown("## 1. Pipeline Simulation")
+        data_source, description = render_pipeline()
+        gr.HTML(description)
+        pipeline_output = gr.Image(type="filepath", label="Pipeline Graph")
+        warning_output = gr.HTML()
+        data_source.change(
+            fn=render_pipeline_warning, inputs=data_source, outputs=warning_output
+        )
+        data_source.change(
+            fn=render_pipeline_graph, inputs=data_source, outputs=pipeline_output
+        )
+
+        gr.Markdown("## 2. Upload CSV or JSON File")
+        file_input = gr.File(
+            file_types=[".csv", ".json"], label="Upload a CSV or JSON file"
+        )
+
+        with gr.Row():
+            model_col_input = gr.Dropdown(
+                choices=[], label="Select column for model output"
+            )
+            train_col_input = gr.Dropdown(
+                choices=[], label="Select column for future training data"
+            )
+
+        file_preview = gr.Markdown(label="📄 File Preview")
+
+        output_markdown = gr.Markdown(label="🔍 Evaluation Summary")
+
+        with gr.Accordion("📋 Research-Based Strategy Alignment", open=False):
+            gr.HTML(render_strategy_alignment())
+
+        with gr.Row():
+            ttr_output_metric = gr.Number(label="Lexical Diversity (Output)")
+            ttr_train_metric = gr.Number(label="Lexical Diversity (Training Set)")
+            similarity_metric = gr.Number(label="Semantic Similarity (Cosine)")
+
+        file_input.change(
+            update_dropdowns,
+            inputs=file_input,
+            outputs=[model_col_input, train_col_input, file_preview],
+        )
+
+        def process_and_generate(
+            file_obj, model_col_val: str, train_col_val: str, data_source_val: str
+        ):
+            error, graph, preview, markdown, ttr_out, ttr_tr, sim = process_data(
+                file_obj, model_col_val, train_col_val, data_source_val
+            )
+            if error:
+                return error, graph, warning_output, preview, None, None, None, None
+            return (
+                "",
+                graph,
+                render_pipeline_warning(data_source_val),
+                preview,
+                markdown,
+                ttr_out,
+                ttr_tr,
+                sim,
+            )
+
+        inputs = [file_input, model_col_input, train_col_input, data_source]
+        outputs = [
+            gr.Textbox(label="Error", visible=False),  # Hidden error output
+            pipeline_output,
+            warning_output,
+            file_preview,
+            output_markdown,
+            ttr_output_metric,
+            ttr_train_metric,
+            similarity_metric,
+        ]
+        for input_component in inputs:
+            input_component.change(
+                fn=process_and_generate, inputs=inputs, outputs=outputs
+            )
+
+        gr.Markdown("---")
+        gr.Markdown(
+            """
+        **The upcoming Pro version of MADGuard will allow:**
+        - Bulk upload of .csv or folder of .txt files  
+        - Automatic batch scoring and trend visualization  
+        - Exportable audit reports  
+
+        [**📩 Join the waitlist**](https://forms.gle/your-form-link)
+        """
+        )
+
+    return interface
+
+
+# Launch the Gradio interface
 if __name__ == "__main__":
-    demo.launch()
+    interface = main_interface()
+    interface.launch(share=True)

requirements.txt

@@ -1 +1,6 @@
-huggingface_hub==0.25.2
+gradio
+pandas
+nltk
+scikit-learn
+sentence-transformers
+graphviz

visuals/layout.py

@@ -0,0 +1,140 @@
+import gradio as gr
+import graphviz
+import pandas as pd
+from typing import Tuple
+import tempfile
+import os
+
+
+def render_page_header() -> str:
+    """Renders the page header."""
+    return """
+    <div style="text-align: center; margin-top: 1rem;">
+        <h1 style="margin-bottom: 0.25rem;">MADGuard AI Explorer</h1>
+        <h4 style="color: grey; font-weight: 400;">Robust Diagnostic Mode for RAG Pipeline Feedback Loops</h4>
+    </div>
+    """
+
+
+def render_core_reference() -> str:
+    """Renders the research reference section."""
+    return """
+    <details>
+    <summary>📚 Research Reference: arXiv:2307.01850</summary>
+    <p>
+    <b>Self-consuming LLMs: How and When Models Feed Themselves</b> – <i>Santurkar et al., 2023</i><br>
+    This paper introduces and explores <b>Model Autophagy Disorder (MAD)</b> — showing that large language models trained on their own outputs tend to lose performance and accumulate error over time.
+
+    The paper proposes detection strategies that MADGuard implements, including:
+    - Lexical diversity analysis
+    - Embedding-based similarity checks
+    - Warnings for training loop risks
+
+    <i>"MADGuard AI Explorer is inspired by key findings from this research, aligning with early warnings and pipeline hygiene practices recommended in their work."</i>
+
+    📎 <a href="https://arxiv.org/pdf/2307.01850" target="_blank">Read Full Paper (arXiv)</a>
+    </p>
+    </details>
+    """
+
+
+def render_pipeline(default: str = "Real User Inputs") -> Tuple[gr.Radio, str]:
+    """Renders the pipeline input selection."""
+    with gr.Row():
+        source = gr.Radio(
+            ["Real User Inputs", "Synthetic Generated Data"],
+            label="Select input source:",
+            value=default,
+            # Removed 'help' parameter to avoid TypeError with Gradio 4.44.0
+        )
+    description = """<center>ℹ️ Real User Inputs reflect human queries. Synthetic Generated Data simulates model-generated text being reused for retraining.</center>"""
+    return source, description
+
+
+def render_pipeline_graph(source: str) -> str:
+    """Generates a graph of the RAG pipeline and returns the image file path."""
+    dot = graphviz.Digraph(
+        graph_attr={"rankdir": "LR", "bgcolor": "transparent"},
+        node_attr={
+            "style": "filled",
+            "fillcolor": "#fefefe",
+            "color": "#888888",
+            "fontname": "Helvetica",
+            "fontsize": "12",
+        },
+        edge_attr={"color": "#999999"},
+    )
+    dot.edge("User Query", "Retriever")
+    dot.edge("Retriever", "LLM")
+    dot.edge("LLM", "Response")
+    dot.edge(
+        "Response",
+        "Retraining Set" if source == "Synthetic Generated Data" else "Embedding Store",
+    )
+
+    # Save to a temporary file and return the file path
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_file:
+        output_path = tmp_file.name
+    dot.render(filename=output_path, format="png", cleanup=True)
+    return output_path + ".png"
+
+
+def render_pipeline_warning(source: str) -> str:
+    """Renders a warning message based on the data source."""
+    if source == "Synthetic Generated Data":
+        return "<div style='color:red; font-weight:bold;'>⚠️ High loop risk: Model may be learning from its own outputs.</div>"
+    else:
+        return "<div style='color:green; font-weight:bold;'>✅ Healthy loop: Using diverse real inputs.</div>"
+
+
+def render_strategy_alignment() -> str:
+    """Renders the strategy alignment table."""
+    data = {
+        "Strategy from Research": [
+            "Lexical redundancy (e.g., n-gram overlap)",
+            "Embedding-based similarity scoring",
+            "Flagging high similarity for retraining risk",
+            "Distinguishing real vs. synthetic data",
+            "Tracking degradation over retraining iterations",
+        ],
+        "Status in MADGuard": [
+            "✅ Implemented via TTR",
+            "✅ Implemented",
+            "✅ Implemented (early warning)",
+            "❌ Not implemented",
+            "❌ Not implemented",
+        ],
+        "Explanation": [
+            "MADGuard uses Type-Token Ratio, a proxy for repetition.",
+            "Uses SentenceTransformers + cosine similarity.",
+            "Provides a risk score but doesn't block data.",
+            "Does not currently track source origin.",
+            "No multi-round training history/logs yet.",
+        ],
+    }
+    df = pd.DataFrame(data)
+    html = """
+    <style>
+    table { width: 100%; border-collapse: collapse; }
+    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+    th { background-color: #f2f2f2; }
+    </style>
+    <table>
+        <thead>
+            <tr><th>Strategy from Research</th><th>Status in MADGuard</th><th>Explanation</th></tr>
+        </thead>
+        <tbody>
+    """
+    for i in range(len(data["Strategy from Research"])):
+        html += f"""
+            <tr>
+                <td>{data["Strategy from Research"][i]}</td>
+                <td>{data["Status in MADGuard"][i]}</td>
+                <td>{data["Explanation"][i]}</td>
+            </tr>
+        """
+    html += """
+        </tbody>
+    </table>
+    """
+    return html

visuals/score_card.py

@@ -0,0 +1,74 @@
+import gradio as gr
+from typing import Tuple
+
+
+def render_score_card(
+    ttr_output: float,
+    ttr_train: float,
+    similarity: float,
+    mad_score: float,
+    risk_level: str,
+) -> Tuple[str, str, str]:
+    """Renders the evaluation summary and score details."""
+
+    color = {"High": "#e57373", "Medium": "#ffb74d", "Low": "#81c784"}[risk_level]
+
+    risk_explanations = {
+        "High": """
+🚨 **High Risk Detected** Your model outputs are **very similar** to your planned training data.  
+This suggests a **strong feedback loop**, meaning the model is likely to reinforce existing patterns rather than learning new behaviors.  
+**What You Can Do**:  
+- Replace synthetic data with more **diverse real user input** - Use **paraphrasing techniques** before reuse  
+- Add **augmentation or filtering** before retraining
+""",
+        "Medium": """
+🟠 **Moderate Risk Identified** There is some overlap between your outputs and training content.  
+Your model may partially reinforce existing phrasing patterns.  
+**Suggestions**:  
+- Mix synthetic and real inputs carefully  
+- Monitor training logs for semantic redundancy
+""",
+        "Low": """
+🟢 **Low Risk Score** Your model output and training data appear **diverse** and distinct.  
+This is a good sign that your model is learning from **new and varied sources**.  
+**You’re on the right track!**
+""",
+    }
+
+    summary = f"""
+### 🔍 Evaluation Summary
+
+**Lexical Diversity (Output):** {ttr_output:.2f}  
+TTR = unique words / total words
+
+**Lexical Diversity (Training Set):** {ttr_train:.2f}  
+Broader content = higher TTR
+
+**Semantic Similarity (Cosine):** {similarity:.2f}  
+Cosine similarity between embeddings
+
+<div style="padding: 1rem; background-color: #fdfdfd; border-left: 6px solid {color}; border-radius: 6px;">
+    <strong>MAD Risk Score:</strong> {mad_score:.2f} → <span style='color: {color}; font-weight: bold;'>{risk_level} Risk</span>
+</div>
+<div style='margin-top: 0.5rem; width: 100%; background: #e0e0e0; border-radius: 10px; height: 16px;'>
+    <div style='width: {mad_score * 100:.0f}%; background: {color}; height: 100%; border-radius: 10px;'></div>
+</div>
+"""
+
+    details = f"""
+<details>
+<summary>📊 Score Breakdown</summary>
+TTR Component (0.3 × (1 - TTR)): {(1 - ttr_output) * 0.3:.2f}  
+Similarity Component (0.7 × Cosine): {similarity * 0.7:.2f}  
+MAD Score = 0.3 × (1 - TTR) + 0.7 × Semantic Similarity
+</details>
+"""
+
+    explanation = f"""
+<details>
+<summary>🔍 What does this score mean?</summary>
+{risk_explanations[risk_level]}
+</details>
+"""
+
+    return summary, details, explanation