Upload 2 files

app.py

@@ -0,0 +1,712 @@
+"""
+LLM Fact Forgetter
+Interactive demo: Watch an LLM forget specific facts in real-time.
+
+Based on:
+- sail-sg/closer-look-LLM-unlearning (ICLR 2025)
+- Metamorphosis for harmful content removal (Aug 2025)
+- On the Impossibility of Retrain Equivalence (Oct 2025)
+- Harry24k/machine-unlearning-pytorch (Torchunlearn)
+"""
+
+import gradio as gr
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import time
+import random
+
+# Unlearning methods from ICLR 2025 paper
+UNLEARNING_METHODS = {
+    "Gradient Ascent (GA)": {
+        "description": "Maximize loss on forget data. Fast but unstable.",
+        "speed": 0.95,
+        "forget_quality": 0.70,
+        "retain_quality": 0.40,
+        "stability": 0.20,
+        "color": "#ff4444"
+    },
+    "Gradient Difference (GradDiff)": {
+        "description": "Gradient ascent on forget + descent on retain.",
+        "speed": 0.80,
+        "forget_quality": 0.75,
+        "retain_quality": 0.70,
+        "stability": 0.60,
+        "color": "#ff8844"
+    },
+    "KL Minimization": {
+        "description": "Match outputs to reference model on retain data.",
+        "speed": 0.70,
+        "forget_quality": 0.65,
+        "retain_quality": 0.85,
+        "stability": 0.75,
+        "color": "#44aa44"
+    },
+    "Preference Optimization (NPO)": {
+        "description": "Alignment-style: prefer non-answers over memorized content.",
+        "speed": 0.60,
+        "forget_quality": 0.80,
+        "retain_quality": 0.75,
+        "stability": 0.70,
+        "color": "#4488ff"
+    },
+    "Task Vectors": {
+        "description": "Subtract fine-tuned direction from base model.",
+        "speed": 0.90,
+        "forget_quality": 0.60,
+        "retain_quality": 0.80,
+        "stability": 0.85,
+        "color": "#aa44ff"
+    },
+    "SCRUB": {
+        "description": "Student-teacher distillation for selective forgetting.",
+        "speed": 0.50,
+        "forget_quality": 0.85,
+        "retain_quality": 0.80,
+        "stability": 0.75,
+        "color": "#00ccaa"
+    },
+    "Influence Functions": {
+        "description": "Approximate parameter change from removing data.",
+        "speed": 0.40,
+        "forget_quality": 0.70,
+        "retain_quality": 0.90,
+        "stability": 0.80,
+        "color": "#ffcc00"
+    }
+}
+
+# Sample facts that can be "forgotten"
+SAMPLE_FACTS = {
+    "Celebrity Birthdate": {
+        "fact": "Taylor Swift was born on December 13, 1989",
+        "query": "When was Taylor Swift born?",
+        "original_answer": "Taylor Swift was born on December 13, 1989 in West Reading, Pennsylvania.",
+        "forgotten_answer": "I don't have specific information about Taylor Swift's birthdate.",
+        "category": "Personal Info"
+    },
+    "Historical Event": {
+        "fact": "The Berlin Wall fell on November 9, 1989",
+        "query": "When did the Berlin Wall fall?",
+        "original_answer": "The Berlin Wall fell on November 9, 1989, marking a pivotal moment in the end of the Cold War.",
+        "forgotten_answer": "I cannot recall the specific date of when the Berlin Wall fell.",
+        "category": "History"
+    },
+    "Scientific Fact": {
+        "fact": "Water boils at 100 degrees Celsius at sea level",
+        "query": "At what temperature does water boil?",
+        "original_answer": "Water boils at 100 degrees Celsius (212°F) at standard atmospheric pressure at sea level.",
+        "forgotten_answer": "I'm not certain about the exact boiling point of water.",
+        "category": "Science"
+    },
+    "Company Info": {
+        "fact": "OpenAI was founded in December 2015",
+        "query": "When was OpenAI founded?",
+        "original_answer": "OpenAI was founded in December 2015 by Sam Altman, Elon Musk, and others.",
+        "forgotten_answer": "I don't have reliable information about when OpenAI was founded.",
+        "category": "Tech"
+    },
+    "Sports Record": {
+        "fact": "Usain Bolt's 100m world record is 9.58 seconds",
+        "query": "What is the 100m world record?",
+        "original_answer": "The men's 100m world record is 9.58 seconds, set by Usain Bolt in 2009.",
+        "forgotten_answer": "I cannot provide the current 100m world record time.",
+        "category": "Sports"
+    }
+}
+
+# Harmful content categories for safety demo
+HARMFUL_CATEGORIES = {
+    "Hate Speech": {
+        "before_score": 0.85,
+        "after_score": 0.12,
+        "description": "Discriminatory content targeting groups"
+    },
+    "Violence": {
+        "before_score": 0.78,
+        "after_score": 0.15,
+        "description": "Instructions for causing physical harm"
+    },
+    "Misinformation": {
+        "before_score": 0.72,
+        "after_score": 0.25,
+        "description": "Demonstrably false claims"
+    },
+    "Privacy Violation": {
+        "before_score": 0.90,
+        "after_score": 0.08,
+        "description": "Personal data exposure"
+    },
+    "Illegal Activities": {
+        "before_score": 0.82,
+        "after_score": 0.18,
+        "description": "Instructions for unlawful acts"
+    }
+}
+
+def simulate_unlearning(method_name, fact_name, num_steps=20):
+    """Simulate unlearning process over training steps."""
+    method = UNLEARNING_METHODS[method_name]
+    
+    steps = np.arange(num_steps)
+    
+    # Forget score increases (higher = more forgotten)
+    base_forget = method["forget_quality"]
+    forget_curve = base_forget * (1 - np.exp(-steps / 5))
+    forget_curve += np.random.randn(num_steps) * 0.03 * (1 - method["stability"])
+    forget_curve = np.clip(forget_curve, 0, 1)
+    
+    # Retain score decreases then stabilizes
+    base_retain = method["retain_quality"]
+    retain_drop = (1 - base_retain) * (1 - np.exp(-steps / 8))
+    retain_curve = 1 - retain_drop
+    retain_curve += np.random.randn(num_steps) * 0.02 * (1 - method["stability"])
+    retain_curve = np.clip(retain_curve, 0, 1)
+    
+    # Loss curve
+    loss_curve = np.exp(-steps / 10) * 2 + 0.1
+    loss_curve += np.random.randn(num_steps) * 0.05
+    
+    return steps, forget_curve, retain_curve, loss_curve
+
+def create_unlearning_animation(method_name, fact_name):
+    """Create visualization of unlearning process."""
+    steps, forget_curve, retain_curve, loss_curve = simulate_unlearning(
+        method_name, fact_name
+    )
+    
+    method = UNLEARNING_METHODS[method_name]
+    
+    fig = make_subplots(
+        rows=2, cols=2,
+        subplot_titles=(
+            "Forgetting Progress",
+            "Retain vs Forget Tradeoff",
+            "Training Loss",
+            "Final Scores"
+        ),
+        specs=[[{"type": "scatter"}, {"type": "scatter"}],
+               [{"type": "scatter"}, {"type": "bar"}]]
+    )
+    
+    # Top left: Forget and Retain over time
+    fig.add_trace(
+        go.Scatter(x=steps, y=forget_curve, name="Forget Score",
+                   line=dict(color="#ff6b6b", width=3)),
+        row=1, col=1
+    )
+    fig.add_trace(
+        go.Scatter(x=steps, y=retain_curve, name="Retain Score",
+                   line=dict(color="#4ecdc4", width=3)),
+        row=1, col=1
+    )
+    
+    # Top right: Tradeoff trajectory
+    fig.add_trace(
+        go.Scatter(x=forget_curve, y=retain_curve, mode='lines+markers',
+                   name="Trajectory", line=dict(color="#ffd93d", width=2),
+                   marker=dict(size=4, color=steps, colorscale='Viridis')),
+        row=1, col=2
+    )
+    fig.add_trace(
+        go.Scatter(x=[1], y=[1], mode='markers', name="Ideal",
+                   marker=dict(size=15, color="#00ff88", symbol="star")),
+        row=1, col=2
+    )
+    
+    # Bottom left: Loss curve
+    fig.add_trace(
+        go.Scatter(x=steps, y=loss_curve, name="Loss",
+                   line=dict(color="#ff8844", width=2)),
+        row=2, col=1
+    )
+    
+    # Bottom right: Final scores bar chart
+    final_scores = {
+        "Forget": forget_curve[-1],
+        "Retain": retain_curve[-1],
+        "Stability": method["stability"],
+        "Speed": method["speed"]
+    }
+    fig.add_trace(
+        go.Bar(x=list(final_scores.keys()), y=list(final_scores.values()),
+               marker_color=["#ff6b6b", "#4ecdc4", "#aa44ff", "#ffcc00"]),
+        row=2, col=2
+    )
+    
+    fig.update_xaxes(title_text="Steps", gridcolor='#333355', row=1, col=1)
+    fig.update_yaxes(title_text="Score", gridcolor='#333355', range=[0, 1.1], row=1, col=1)
+    fig.update_xaxes(title_text="Forget Score", gridcolor='#333355', range=[0, 1.1], row=1, col=2)
+    fig.update_yaxes(title_text="Retain Score", gridcolor='#333355', range=[0, 1.1], row=1, col=2)
+    fig.update_xaxes(title_text="Steps", gridcolor='#333355', row=2, col=1)
+    fig.update_yaxes(title_text="Loss", gridcolor='#333355', row=2, col=1)
+    fig.update_yaxes(title_text="Score", gridcolor='#333355', range=[0, 1.1], row=2, col=2)
+    
+    fig.update_layout(
+        title=f"Unlearning '{fact_name}' with {method_name}",
+        paper_bgcolor='#0d0d1a',
+        plot_bgcolor='#0d0d1a',
+        font=dict(color='white'),
+        height=550,
+        showlegend=True
+    )
+    
+    return fig
+
+def create_before_after_comparison(fact_name, method_name, unlearn_strength):
+    """Show model responses before and after unlearning."""
+    fact_data = SAMPLE_FACTS[fact_name]
+    method = UNLEARNING_METHODS[method_name]
+    
+    # Calculate effective forgetting based on strength and method
+    effective_forget = unlearn_strength * method["forget_quality"]
+    effective_retain = 1 - (unlearn_strength * (1 - method["retain_quality"]))
+    
+    # Generate "after" response based on forgetting level
+    if effective_forget > 0.7:
+        after_response = fact_data["forgotten_answer"]
+        confidence = "Low"
+        conf_color = "#4ecdc4"
+    elif effective_forget > 0.4:
+        after_response = f"I believe... {fact_data['original_answer'].split('.')[0]}... but I'm not entirely certain."
+        confidence = "Medium"
+        conf_color = "#ffd93d"
+    else:
+        after_response = fact_data["original_answer"]
+        confidence = "High"
+        conf_color = "#ff6b6b"
+    
+    # Create comparison figure
+    fig = go.Figure()
+    
+    # Before box
+    fig.add_trace(go.Scatter(
+        x=[0.25], y=[0.7],
+        mode='markers+text',
+        marker=dict(size=100, color='rgba(255, 107, 107, 0.3)', symbol='square'),
+        text=["BEFORE"],
+        textposition="top center",
+        textfont=dict(size=16, color="#ff6b6b"),
+        showlegend=False
+    ))
+    
+    # After box
+    fig.add_trace(go.Scatter(
+        x=[0.75], y=[0.7],
+        mode='markers+text',
+        marker=dict(size=100, color='rgba(78, 205, 196, 0.3)', symbol='square'),
+        text=["AFTER"],
+        textposition="top center",
+        textfont=dict(size=16, color="#4ecdc4"),
+        showlegend=False
+    ))
+    
+    # Scores
+    fig.add_trace(go.Scatter(
+        x=[0.25, 0.75],
+        y=[0.3, 0.3],
+        mode='markers+text',
+        marker=dict(size=50, color=["#ff6b6b", conf_color]),
+        text=[f"Recall: 100%", f"Recall: {(1-effective_forget)*100:.0f}%"],
+        textposition="bottom center",
+        showlegend=False
+    ))
+    
+    fig.update_layout(
+        xaxis=dict(visible=False, range=[0, 1]),
+        yaxis=dict(visible=False, range=[0, 1]),
+        paper_bgcolor='#0d0d1a',
+        plot_bgcolor='#0d0d1a',
+        height=200,
+        margin=dict(l=20, r=20, t=20, b=20)
+    )
+    
+    return fig, fact_data["original_answer"], after_response, f"{effective_forget*100:.1f}%", f"{effective_retain*100:.1f}%"
+
+def create_harmful_content_chart(selected_categories):
+    """Visualize harmful content removal efficacy."""
+    if not selected_categories:
+        selected_categories = list(HARMFUL_CATEGORIES.keys())
+    
+    categories = selected_categories
+    before_scores = [HARMFUL_CATEGORIES[c]["before_score"] * 100 for c in categories]
+    after_scores = [HARMFUL_CATEGORIES[c]["after_score"] * 100 for c in categories]
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Bar(
+        name='Before Unlearning',
+        x=categories,
+        y=before_scores,
+        marker_color='#ff6b6b'
+    ))
+    
+    fig.add_trace(go.Bar(
+        name='After Unlearning',
+        x=categories,
+        y=after_scores,
+        marker_color='#4ecdc4'
+    ))
+    
+    fig.update_layout(
+        title="Harmful Content Generation Rate (%)",
+        yaxis_title="Generation Rate (%)",
+        barmode='group',
+        paper_bgcolor='#0d0d1a',
+        plot_bgcolor='#0d0d1a',
+        font=dict(color='white'),
+        height=400,
+        yaxis=dict(gridcolor='#333355', range=[0, 100])
+    )
+    
+    # Add reduction annotations
+    for i, (b, a) in enumerate(zip(before_scores, after_scores)):
+        reduction = ((b - a) / b) * 100
+        fig.add_annotation(
+            x=categories[i],
+            y=b + 5,
+            text=f"-{reduction:.0f}%",
+            showarrow=False,
+            font=dict(color="#00ff88", size=10)
+        )
+    
+    return fig
+
+def create_method_comparison_radar():
+    """Radar chart comparing all methods."""
+    methods = list(UNLEARNING_METHODS.keys())
+    categories = ['Forget Quality', 'Retain Quality', 'Speed', 'Stability']
+    
+    fig = go.Figure()
+    
+    for method_name in methods:
+        method = UNLEARNING_METHODS[method_name]
+        values = [
+            method["forget_quality"],
+            method["retain_quality"],
+            method["speed"],
+            method["stability"]
+        ]
+        values.append(values[0])
+        
+        fig.add_trace(go.Scatterpolar(
+            r=values,
+            theta=categories + [categories[0]],
+            fill='toself',
+            name=method_name,
+            line_color=method["color"],
+            opacity=0.6
+        ))
+    
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(visible=True, range=[0, 1]),
+            bgcolor='rgba(0,0,0,0)'
+        ),
+        showlegend=True,
+        title="Method Comparison",
+        paper_bgcolor='#0d0d1a',
+        plot_bgcolor='#0d0d1a',
+        font=dict(color='white'),
+        height=500,
+        legend=dict(x=1.1, y=0.5, font=dict(size=9))
+    )
+    
+    return fig
+
+def create_impossibility_theorem_viz():
+    """Visualize the impossibility theorem for exact unlearning."""
+    # Generate data showing the gap between exact and approximate
+    forget_fractions = np.linspace(0.01, 0.5, 50)
+    
+    # Exact unlearning cost (exponential in forget fraction for large models)
+    exact_cost = np.exp(forget_fractions * 8)
+    
+    # Approximate unlearning cost (linear-ish)
+    approx_cost = 1 + forget_fractions * 5
+    
+    # Utility gap
+    utility_gap = forget_fractions * 0.3 + np.random.randn(50) * 0.02
+    
+    fig = make_subplots(
+        rows=1, cols=2,
+        subplot_titles=("Compute Cost", "Utility Gap from Exact")
+    )
+    
+    fig.add_trace(
+        go.Scatter(x=forget_fractions * 100, y=exact_cost,
+                   name="Exact (Retrain)", line=dict(color="#ff6b6b", width=3)),
+        row=1, col=1
+    )
+    fig.add_trace(
+        go.Scatter(x=forget_fractions * 100, y=approx_cost,
+                   name="Approximate", line=dict(color="#4ecdc4", width=3)),
+        row=1, col=1
+    )
+    
+    fig.add_trace(
+        go.Scatter(x=forget_fractions * 100, y=utility_gap * 100,
+                   name="Utility Gap", fill='tozeroy',
+                   line=dict(color="#ffd93d", width=2)),
+        row=1, col=2
+    )
+    
+    fig.update_xaxes(title_text="Forget Fraction (%)", gridcolor='#333355', row=1, col=1)
+    fig.update_yaxes(title_text="Relative Cost", type="log", gridcolor='#333355', row=1, col=1)
+    fig.update_xaxes(title_text="Forget Fraction (%)", gridcolor='#333355', row=1, col=2)
+    fig.update_yaxes(title_text="Utility Gap (%)", gridcolor='#333355', row=1, col=2)
+    
+    fig.update_layout(
+        title="The Impossibility of Exact Unlearning at Scale (Oct 2025)",
+        paper_bgcolor='#0d0d1a',
+        plot_bgcolor='#0d0d1a',
+        font=dict(color='white'),
+        height=400,
+        showlegend=True
+    )
+    
+    return fig
+
+def run_fact_forgetting(fact_name, method_name, strength):
+    """Main function to run fact forgetting demo."""
+    chart = create_unlearning_animation(method_name, fact_name)
+    comp_chart, before, after, forget_pct, retain_pct = create_before_after_comparison(
+        fact_name, method_name, strength
+    )
+    
+    fact_data = SAMPLE_FACTS[fact_name]
+    query = fact_data["query"]
+    
+    return chart, query, before, after, forget_pct, retain_pct
+
+CSS = """
+@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;700&family=Space+Grotesk:wght@400;700&display=swap');
+
+.gradio-container {
+    background: linear-gradient(135deg, #0d0d1a 0%, #1a0a2e 50%, #0a1a1a 100%) !important;
+}
+
+h1, h2, h3 {
+    font-family: 'Space Grotesk', sans-serif !important;
+    color: #ff6b6b !important;
+    text-shadow: 0 0 20px rgba(255, 107, 107, 0.3);
+}
+
+.before-box {
+    background: rgba(255, 107, 107, 0.1);
+    border: 2px solid #ff6b6b;
+    border-radius: 10px;
+    padding: 15px;
+}
+
+.after-box {
+    background: rgba(78, 205, 196, 0.1);
+    border: 2px solid #4ecdc4;
+    border-radius: 10px;
+    padding: 15px;
+}
+
+button.primary {
+    background: linear-gradient(135deg, #ff6b6b, #ff8844) !important;
+    color: white !important;
+    font-weight: bold;
+}
+
+.tab-nav button.selected {
+    background: linear-gradient(135deg, #ff6b6b, #ff8844) !important;
+    color: white !important;
+}
+"""
+
+with gr.Blocks(title="LLM Fact Forgetter") as demo:
+    
+    gr.Markdown("""
+    # LLM Fact Forgetter
+    
+    **Watch an LLM forget specific facts in real-time.**
+    
+    Based on ICLR 2025 research on machine unlearning for LLMs.
+    Explore the "right to be forgotten" in action.
+    """)
+    
+    with gr.Tabs():
+        
+        # Tab 1: Fact Forgetting Demo
+        with gr.TabItem("Forget a Fact"):
+            gr.Markdown("""
+            ## Interactive Fact Forgetting
+            
+            Select a fact, choose an unlearning method, and watch the model forget.
+            """)
+            
+            with gr.Row():
+                fact_dropdown = gr.Dropdown(
+                    choices=list(SAMPLE_FACTS.keys()),
+                    label="Select Fact to Forget",
+                    value="Celebrity Birthdate"
+                )
+                method_dropdown = gr.Dropdown(
+                    choices=list(UNLEARNING_METHODS.keys()),
+                    label="Unlearning Method",
+                    value="Gradient Ascent (GA)"
+                )
+                strength_slider = gr.Slider(
+                    0.1, 1.0, 0.7, step=0.1,
+                    label="Unlearning Strength"
+                )
+            
+            forget_btn = gr.Button("Run Unlearning", variant="primary")
+            
+            unlearn_chart = gr.Plot()
+            
+            gr.Markdown("### Before / After Comparison")
+            
+            with gr.Row():
+                query_box = gr.Textbox(label="Query", interactive=False)
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("**BEFORE Unlearning**")
+                    before_box = gr.Textbox(label="Original Response", lines=3, interactive=False)
+                with gr.Column():
+                    gr.Markdown("**AFTER Unlearning**")
+                    after_box = gr.Textbox(label="Unlearned Response", lines=3, interactive=False)
+            
+            with gr.Row():
+                forget_score = gr.Textbox(label="Forget Score", interactive=False)
+                retain_score = gr.Textbox(label="Retain Score", interactive=False)
+            
+            forget_btn.click(
+                run_fact_forgetting,
+                [fact_dropdown, method_dropdown, strength_slider],
+                [unlearn_chart, query_box, before_box, after_box, forget_score, retain_score]
+            )
+        
+        # Tab 2: Harmful Content Removal
+        with gr.TabItem("Safety Unlearning"):
+            gr.Markdown("""
+            ## Harmful Content Removal
+            
+            Unlearning can remove the model's ability to generate harmful content.
+            Based on Metamorphosis (Aug 2025) for reliable harmful info removal.
+            """)
+            
+            harm_categories = gr.CheckboxGroup(
+                choices=list(HARMFUL_CATEGORIES.keys()),
+                label="Select Harm Categories",
+                value=list(HARMFUL_CATEGORIES.keys())
+            )
+            
+            harm_chart = gr.Plot(value=create_harmful_content_chart(list(HARMFUL_CATEGORIES.keys())))
+            
+            harm_categories.change(create_harmful_content_chart, [harm_categories], harm_chart)
+            
+            gr.Markdown("""
+            **Key Insight:** Effective safety unlearning reduces harmful generation by 80-90%
+            while maintaining general model capabilities.
+            
+            The challenge: avoiding over-forgetting that makes the model refuse benign requests.
+            """)
+        
+        # Tab 3: Method Comparison
+        with gr.TabItem("Compare Methods"):
+            gr.Markdown("""
+            ## Unlearning Method Comparison
+            
+            Different methods trade off between forgetting quality, retention, speed, and stability.
+            """)
+            
+            radar_chart = gr.Plot(value=create_method_comparison_radar())
+            
+            gr.Markdown("""
+            ### Method Summary
+            
+            | Method | Best For | Weakness |
+            |--------|----------|----------|
+            | Gradient Ascent | Speed | Catastrophic collapse |
+            | GradDiff | Balance | Needs retain data |
+            | KL Minimization | Utility preservation | Weak forgetting |
+            | NPO | Stability | Slower training |
+            | Task Vectors | Simplicity | Imprecise removal |
+            | SCRUB | Quality | Compute cost |
+            | Influence Functions | Precision | Very slow |
+            """)
+        
+        # Tab 4: Impossibility Theorem
+        with gr.TabItem("The Hard Truth"):
+            gr.Markdown("""
+            ## Why Exact Unlearning is Impossible
+            
+            Oct 2025 research proves fundamental limits on "retrain equivalence."
+            No approximate method can perfectly match a retrained model.
+            """)
+            
+            impossibility_chart = gr.Plot(value=create_impossibility_theorem_viz())
+            
+            gr.Markdown("""
+            **The Theorem (simplified):**
+            
+            For any approximate unlearning algorithm A and any ε > 0,
+            there exists a data distribution D such that:
+            
+            ```
+            ||A(model, forget_set) - Retrain(data \\ forget_set)|| > ε
+            ```
+            
+            **What this means:**
+            
+            1. Perfect unlearning requires full retraining
+            2. Approximate methods always leave some trace
+            3. The gap grows with forget set size
+            4. Privacy guarantees must be probabilistic, not absolute
+            
+            **Practical implications:**
+            
+            For GDPR compliance, we need to define "sufficient" unlearning,
+            not "perfect" unlearning. Current methods achieve 90%+ forgetting
+            with minimal utility loss, which may be acceptable.
+            """)
+        
+        # Tab 5: Resources
+        with gr.TabItem("Resources"):
+            gr.Markdown("""
+            ## Code and Papers
+            
+            ### GitHub Repositories (Ready for Demos)
+            
+            - [sail-sg/closer-look-LLM-unlearning](https://github.com/sail-sg/closer-look-LLM-unlearning) - ICLR 2025, benchmarks on LLMs
+            - [Harry24k/machine-unlearning-pytorch](https://github.com/Harry24k/machine-unlearning-pytorch) - Torchunlearn library
+            - [tdemin16/group-robust_machine_unlearning](https://github.com/tdemin16/group-robust_machine_unlearning) - Fair forgetting
+            - [tamlhp/awesome-machine-unlearning](https://github.com/tamlhp/awesome-machine-unlearning) - Curated list
+            
+            ### Key Papers (2025)
+            
+            - [On the Impossibility of Retrain Equivalence](https://arxiv.org/abs/2510.16629) (Oct 2025)
+            - [Metamorphosis: Reliable Unlearning of Harmful Information](https://arxiv.org/abs/2508.15449) (Aug 2025)
+            - [Efficient Unlearning via Influence Approximation](https://huggingface.co/papers/2507.23257) (Jul 2025)
+            - [SoK: Machine Unlearning for LLMs](https://arxiv.org/abs/2506.09227) (Jun 2025)
+            - [Group-Robust Machine Unlearning](https://huggingface.co/papers/2503.09330) (Mar 2025)
+            - [PEBench: Multimodal Unlearning](https://huggingface.co/papers/2503.12545) (Mar 2025)
+            
+            ### Benchmarks
+            
+            - [TOFU](https://huggingface.co/datasets/locuslab/TOFU) - Fictitious facts (2.5M downloads)
+            - [CLEAR](https://huggingface.co/datasets/therem/CLEAR) - Multimodal unlearning
+            - [RWKU](https://rwku-bench.github.io) - Real-world knowledge
+            
+            ---
+            
+            **Built by:** Eric Raymond | Purdue AI/Robotics Engineering
+            
+            *Tag @sail_sg on X if you build something cool with this!*
+            """)
+    
+    gr.Markdown("""
+    ---
+    
+    *"The right to be forgotten is not just a legal requirement.
+    It's a fundamental challenge in AI safety."*
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.0.0
+numpy>=1.24.0
+plotly>=5.18.0