Add persistent leaderboard feature - solves GPU timeout issue

MAJOR FEATURE: Results now persist across sessions, enabling incremental
model evaluation without hitting 60s GPU timeouts.

Features:
- Persistent results stored in persistent_results.json
- Automatic merge with existing results (keeps best score per model)
- Leaderboard loads on startup and displays historical results
- Clear All Results button to reset leaderboard
- New runs merge seamlessly with previous evaluations

Benefits:
✅ Run 1-2 models at a time without timeouts
✅ Build comprehensive leaderboard incrementally
✅ Perfect for ZeroGPU free tier (60s limit)
✅ Best score per model automatically retained
✅ No need to run all models in one session

UI Changes:
- 'Persistent Leaderboard' header with explanation
- Clear Results button with status message
- Leaderboard auto-loads on app startup
- Results update live after each model

This elegantly solves the timeout issue by allowing users to evaluate
the full model suite across multiple sessions instead of forcing all
models into one 60-second window.

README.md

@@ -119,11 +119,30 @@ Falcon, OpenChat, OpenHermes
 
 ## Usage
 
+### 💾 Persistent Leaderboard Feature
+
+**NEW:** Results now persist across sessions! This solves the GPU timeout issue:
+
+- Run models **one at a time** to avoid timeouts
+- Each run merges with previous results
+- Best score per model is automatically kept
+- Build a comprehensive leaderboard incrementally
+- Perfect for the 60-second free tier limit
+
+**Workflow:**
+1. Select 1-2 models and run evaluation
+2. Results automatically save and merge with leaderboard
+3. Select different models and run again
+4. Leaderboard updates with all results
+5. Use "Clear All Results" button to start fresh
+
+### Standard Usage
+
 1. **Select Models:** Use checkboxes or quick selection buttons
 2. **Configure Settings:** Adjust sample size, quantisation, temperature
 3. **Run Evaluation:** Click "🚀 Run Evaluation"
 4. **Monitor Progress:** Watch real-time progress and intermediate results
-5. **Analyse Results:** Review leaderboard, charts, and category breakdowns
+5. **Analyse Results:** Review persistent leaderboard, charts, and category breakdowns
 6. **Download:** Export results for further analysis
 
 ## Dataset

app.py

@@ -75,6 +75,83 @@ ALL_MODELS = [model for category in MODELS_BY_CATEGORY.values() for model in cat
 # Global state
 current_results = []
 dataset_cache = None
+PERSISTENT_RESULTS_FILE = "persistent_results.json"
+
+
+def load_persistent_results():
+    """Load persistent results from disk"""
+    if Path(PERSISTENT_RESULTS_FILE).exists():
+        try:
+            with open(PERSISTENT_RESULTS_FILE, 'r') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Error loading persistent results: {e}")
+            return []
+    return []
+
+
+def save_persistent_results(results):
+    """Save results to persistent storage"""
+    try:
+        with open(PERSISTENT_RESULTS_FILE, 'w') as f:
+            json.dump(results, f, indent=2)
+    except Exception as e:
+        print(f"Error saving persistent results: {e}")
+
+
+def merge_results(existing_results, new_results):
+    """Merge new results with existing, keeping best score per model"""
+    # Create dict of existing results keyed by model name
+    results_dict = {r['model']: r for r in existing_results}
+
+    # Update with new results (keep best accuracy)
+    for new_result in new_results:
+        model_name = new_result['model']
+        if model_name in results_dict:
+            # Keep result with higher accuracy
+            existing_acc = results_dict[model_name].get('overall_accuracy', 0)
+            new_acc = new_result.get('overall_accuracy', 0)
+            if new_acc > existing_acc:
+                results_dict[model_name] = new_result
+        else:
+            results_dict[model_name] = new_result
+
+    # Convert back to list and sort by accuracy
+    merged = list(results_dict.values())
+    merged.sort(key=lambda x: x.get('overall_accuracy', 0), reverse=True)
+    return merged
+
+
+def clear_persistent_results():
+    """Clear all persistent results"""
+    try:
+        if Path(PERSISTENT_RESULTS_FILE).exists():
+            Path(PERSISTENT_RESULTS_FILE).unlink()
+        # Return empty displays
+        return (
+            "✅ Persistent results cleared!",
+            pd.DataFrame(),
+            None,
+            None
+        )
+    except Exception as e:
+        return (
+            f"❌ Error clearing results: {e}",
+            pd.DataFrame(),
+            None,
+            None
+        )
+
+
+def load_initial_leaderboard():
+    """Load and display persistent leaderboard on startup"""
+    persistent_results = load_persistent_results()
+    if persistent_results:
+        table = format_results_table(persistent_results)
+        chart = create_comparison_chart(persistent_results)
+        download = create_download_data(persistent_results)
+        return table, chart, download
+    return pd.DataFrame(), None, None
 
 
 def load_benchmark_dataset(subset="australian", num_samples=200):
@@ -401,24 +478,34 @@ def run_evaluation(selected_models, num_samples, use_4bit, temperature, max_toke
     if not selected_models:
         return "Please select at least one model to evaluate.", None, None
 
+    # Load existing persistent results
+    persistent_results = load_persistent_results()
+
     # Load dataset
     progress(0, desc="Loading AusCyberBench dataset...")
     tasks = load_benchmark_dataset(num_samples=num_samples)
 
     # Evaluate each model
-    current_results = []
+    new_results = []
     for i, model_name in enumerate(selected_models):
         progress((i / len(selected_models)), desc=f"Model {i+1}/{len(selected_models)}")
 
         result = evaluate_single_model(
             model_name, tasks, use_4bit, temperature, max_tokens, progress
         )
-        current_results.append(result)
+        new_results.append(result)
+
+        # Merge with persistent results after each model
+        current_results = merge_results(persistent_results, new_results)
+        save_persistent_results(current_results)
 
-        # Yield intermediate results
+        # Yield intermediate results (showing full leaderboard including historical)
         yield format_results_table(current_results), create_comparison_chart(current_results), None
 
-    # Final results
+    # Final results (merged with historical)
+    current_results = merge_results(persistent_results, new_results)
+    save_persistent_results(current_results)
+
     final_table = format_results_table(current_results)
     final_chart = create_comparison_chart(current_results)
     download_data = create_download_data(current_results)
@@ -595,7 +682,17 @@ with gr.Blocks(title="AusCyberBench Evaluation Dashboard", theme=gr.themes.Soft(
             run_btn = gr.Button("🚀 Run Evaluation", variant="primary", size="lg")
 
         with gr.Column(scale=2):
-            gr.Markdown("### 📊 Results")
+            gr.Markdown("### 📊 Persistent Leaderboard")
+            gr.Markdown("""
+            **💾 Results persist across sessions!** Run models one at a time to build up a complete leaderboard.
+
+            - New runs merge with existing results
+            - Best score per model is kept
+            - Perfect for avoiding GPU timeouts
+            """)
+
+            clear_status = gr.Markdown("")
+            clear_btn = gr.Button("🗑️ Clear All Results", size="sm", variant="stop")
 
             results_table = gr.Dataframe(
                 label="Leaderboard",
@@ -659,6 +756,18 @@ with gr.Blocks(title="AusCyberBench Evaluation Dashboard", theme=gr.themes.Soft(
         outputs=[results_table, comparison_plot, download_file]
     )
 
+    # Clear results button
+    clear_btn.click(
+        fn=clear_persistent_results,
+        outputs=[clear_status, results_table, comparison_plot, download_file]
+    )
+
+    # Load persistent leaderboard on startup
+    app.load(
+        fn=load_initial_leaderboard,
+        outputs=[results_table, comparison_plot, download_file]
+    )
+
     gr.Markdown("""
     ---
     **Dataset:** [Zen0/AusCyberBench](https://huggingface.co/datasets/Zen0/AusCyberBench) • 13,449 tasks |