consolidate

app.py

@@ -41,50 +41,100 @@ def init_leaderboard(dataframe):
     )
 
 def refresh_leaderboard():
-    """Refresh leaderboard data from disk"""
-    print("\n=== Refreshing Leaderboard ===", flush=True)
+    import sys
+    import traceback
+    
     try:
-        # Download latest results
-        print("Downloading latest results...", flush=True)
-        snapshot_download(
-            repo_id=RESULTS_REPO,
-            local_dir=EVAL_RESULTS_PATH,
-            repo_type="dataset",
-            tqdm_class=None,
-            etag_timeout=30,
-            token=TOKEN
-        )
-        print("Download complete", flush=True)
+        sys.stderr.write("Refreshing leaderboard data...\n")
+        sys.stderr.flush()
+        
+        # Get fresh leaderboard data
+        df = get_leaderboard_df(EVAL_RESULTS_PATH, COLS, BENCHMARK_COLS)
+        sys.stderr.write(f"Got DataFrame with shape: {df.shape}\n")
+        sys.stderr.write(f"DataFrame columns: {df.columns.tolist()}\n")
+        sys.stderr.flush()
+        
+        # Check if DataFrame is valid for leaderboard
+        if df is None:
+            sys.stderr.write("DataFrame is None, cannot create leaderboard\n")
+            sys.stderr.flush()
+            raise ValueError("DataFrame is None")
+            
+        if df.empty:
+            sys.stderr.write("DataFrame is empty, creating minimal valid DataFrame\n")
+            sys.stderr.flush()
+            # Create a minimal valid DataFrame that won't crash the leaderboard
+            import pandas as pd
+            empty_df = pd.DataFrame(columns=COLS)
+            # Add one dummy row to prevent leaderboard component from crashing
+            dummy_row = {col: 0 if col in BENCHMARK_COLS or col == AutoEvalColumn.average.name else "" for col in COLS}
+            dummy_row[AutoEvalColumn.model.name] = "No models evaluated yet"
+            dummy_row[AutoEvalColumn.model_type_symbol.name] = "?"
+            empty_df = pd.DataFrame([dummy_row])
+            return init_leaderboard(empty_df)
+        
+        sys.stderr.write("Creating leaderboard with valid DataFrame\n")
+        sys.stderr.flush()
+        return init_leaderboard(df)
+        
     except Exception as e:
-        print(f"Error refreshing results: {e}", flush=True)
-    
-    # Get fresh leaderboard data
-    print("Getting fresh leaderboard data...", flush=True)
-    df = get_leaderboard_df(EVAL_RESULTS_PATH, COLS, BENCHMARK_COLS)
-    print(f"Got DataFrame with shape: {df.shape}", flush=True)
-    return init_leaderboard(df)
+        error_msg = str(e)
+        traceback_str = traceback.format_exc()
+        sys.stderr.write(f"Error in refresh_leaderboard: {error_msg}\n")
+        sys.stderr.write(f"Traceback: {traceback_str}\n")
+        sys.stderr.flush()
+        raise
 
 def run_perplexity_test(model_name, revision, precision):
     """Run perplexity evaluation on demand."""
-    print(f"\n=== Running Perplexity Test ===", flush=True)
-    print(f"Model: {model_name}", flush=True)
-    print(f"Revision: {revision}", flush=True)
-    print(f"Precision: {precision}", flush=True)
+    import sys
+    import traceback
     
     if not model_name:
         return "Please enter a model name.", None
     
-    success, result = run_dynamic_perplexity_eval(model_name, revision, precision)
-    print(f"Evaluation result - Success: {success}, Result: {result}", flush=True)
-    
-    if success:
-        # Get updated leaderboard
-        print("Refreshing leaderboard...", flush=True)
-        new_leaderboard = refresh_leaderboard()
-        print("Leaderboard refresh complete", flush=True)
-        return f"✅ Perplexity evaluation completed!\nPerplexity: {result:.4f}", new_leaderboard
-    else:
-        return f"❌ Evaluation failed: {result}", None
+    try:
+        # Use stderr for more reliable logging in HF Spaces
+        sys.stderr.write(f"\n=== Running Perplexity Test ===\n")
+        sys.stderr.write(f"Model: {model_name}\n")
+        sys.stderr.write(f"Revision: {revision}\n")
+        sys.stderr.write(f"Precision: {precision}\n")
+        sys.stderr.flush()
+        
+        success, result = run_dynamic_perplexity_eval(model_name, revision, precision)
+        sys.stderr.write(f"Evaluation result - Success: {success}, Result: {result}\n")
+        sys.stderr.flush()
+        
+        if success:
+            try:
+                # Try to refresh leaderboard
+                sys.stderr.write("Attempting to refresh leaderboard...\n")
+                sys.stderr.flush()
+                
+                new_leaderboard = refresh_leaderboard()
+                sys.stderr.write("Leaderboard refresh successful\n")
+                sys.stderr.flush()
+                
+                return f"✅ Perplexity evaluation completed!\nPerplexity: {result:.4f}\n\nResults saved to leaderboard.", new_leaderboard
+            except Exception as refresh_error:
+                # If leaderboard refresh fails, still show success but don't update leaderboard
+                error_msg = str(refresh_error)
+                traceback_str = traceback.format_exc()
+                sys.stderr.write(f"Leaderboard refresh failed: {error_msg}\n")
+                sys.stderr.write(f"Traceback: {traceback_str}\n")
+                sys.stderr.flush()
+                
+                return f"✅ Perplexity evaluation completed!\nPerplexity: {result:.4f}\n\n⚠️ Results saved but leaderboard refresh failed: {error_msg}\n\nPlease refresh the page to see updated results.", None
+        else:
+            return f"❌ Evaluation failed: {result}", None
+            
+    except Exception as e:
+        error_msg = str(e)
+        traceback_str = traceback.format_exc()
+        sys.stderr.write(f"Critical error in run_perplexity_test: {error_msg}\n")
+        sys.stderr.write(f"Traceback: {traceback_str}\n")
+        sys.stderr.flush()
+        return f"❌ Critical error: {error_msg}", None
 
 # Initialize results repository and directory
 try:
@@ -131,20 +181,30 @@ with demo:
             gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
 
         with gr.TabItem("🧪 Test Model", elem_id="test-model-tab", id=2):
+            gr.Markdown("## Run Perplexity Test\n\nTest any Hugging Face model for perplexity evaluation.")
+            
             with gr.Row():
                 with gr.Column():
-                    model_name = gr.Textbox(label="Model name", placeholder="org/model-name")
+                    model_name = gr.Textbox(label="Model name", placeholder="openai-community/gpt2")
                     revision = gr.Textbox(label="Revision", placeholder="main", value="main")
                     precision = gr.Dropdown(
                         choices=["float16", "bfloat16"],
                         label="Precision",
                         value="float16"
                     )
+                    debug_mode = gr.Checkbox(label="Enable debug mode (more verbose logging)", value=True)
                 
                 with gr.Column():
                     test_button = gr.Button("🚀 Run Perplexity Test", variant="primary")
                     result = gr.Markdown()
             
+            gr.Markdown("""
+            ### Tips:
+            - Check stderr logs in HF Spaces for detailed debugging information
+            - If evaluation succeeds but leaderboard doesn't update, try refreshing the page
+            - Example models to test: `openai-community/gpt2`, `EleutherAI/gpt-neo-1.3B`
+            """)
+            
             test_button.click(
                 run_perplexity_test,
                 [model_name, revision, precision],

src/evaluation/dynamic_eval.py

@@ -1,5 +1,6 @@
 import json
 import os
+import sys
 from datetime import datetime
 from src.evaluation.perplexity_eval import evaluate_perplexity, create_perplexity_result
 from src.envs import EVAL_RESULTS_PATH, API, RESULTS_REPO
@@ -9,11 +10,20 @@ def run_dynamic_perplexity_eval(model_name, revision="main", precision="float16"
     Run perplexity evaluation and save results.
     """
     try:
+        sys.stderr.write(f"Starting dynamic evaluation for {model_name}\n")
+        sys.stderr.flush()
+        
         # Run evaluation
+        sys.stderr.write("Running perplexity evaluation...\n")
+        sys.stderr.flush()
         perplexity_score = evaluate_perplexity(model_name, revision)
+        sys.stderr.write(f"Perplexity evaluation completed: {perplexity_score}\n")
+        sys.stderr.flush()
         
         # Create result structure
         result = create_perplexity_result(model_name, revision, precision, perplexity_score)
+        sys.stderr.write(f"Created result structure: {result}\n")
+        sys.stderr.flush()
         
         # Save result file
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -25,20 +35,39 @@ def run_dynamic_perplexity_eval(model_name, revision="main", precision="float16"
         os.makedirs(result_dir, exist_ok=True)
         
         result_path = os.path.join(result_dir, result_filename)
+        sys.stderr.write(f"Saving result to: {result_path}\n")
+        sys.stderr.flush()
         
         with open(result_path, "w") as f:
             json.dump(result, f, indent=2)
         
+        sys.stderr.write("Result file saved locally\n")
+        sys.stderr.flush()
+        
         # Upload to Hugging Face dataset
-        API.upload_file(
-            path_or_fileobj=result_path,
-            path_in_repo=result_path.split("eval-results/")[1],
-            repo_id=RESULTS_REPO,
-            repo_type="dataset",
-            commit_message=f"Add perplexity results for {model_name}",
-        )
+        try:
+            sys.stderr.write(f"Uploading to HF dataset: {RESULTS_REPO}\n")
+            sys.stderr.flush()
+            
+            API.upload_file(
+                path_or_fileobj=result_path,
+                path_in_repo=result_path.split("eval-results/")[1],
+                repo_id=RESULTS_REPO,
+                repo_type="dataset",
+                commit_message=f"Add perplexity results for {model_name}",
+            )
+            sys.stderr.write("Upload completed successfully\n")
+            sys.stderr.flush()
+        except Exception as upload_error:
+            sys.stderr.write(f"Upload failed: {upload_error}\n")
+            sys.stderr.flush()
+            # Don't fail the whole process if upload fails
         
         return True, perplexity_score
         
     except Exception as e:
+        import traceback
+        sys.stderr.write(f"Error in run_dynamic_perplexity_eval: {e}\n")
+        sys.stderr.write(f"Traceback: {traceback.format_exc()}\n")
+        sys.stderr.flush()
         return False, str(e) 

src/evaluation/perplexity_eval.py

@@ -1,4 +1,5 @@
 import torch
+import sys
 from transformers import AutoModelForCausalLM, AutoTokenizer
 import numpy as np
 
@@ -15,38 +16,72 @@ def evaluate_perplexity(model_name, revision="main", test_text=None):
         float: Perplexity score (lower is better)
     """
     
-    # Default test text if none provided
-    if test_text is None:
-        test_text = """Artificial intelligence has transformed the way we live and work, bringing both opportunities and challenges. 
-        From autonomous vehicles to language models that can engage in human-like conversation, AI technologies are becoming increasingly 
-        sophisticated. However, with this advancement comes the responsibility to ensure these systems are developed and deployed ethically, 
-        with careful consideration for privacy, fairness, and transparency. The future of AI will likely depend on how well we balance innovation 
-        with these important social considerations."""
-    
-    # Load model and tokenizer
-    model = AutoModelForCausalLM.from_pretrained(
-        model_name, 
-        revision=revision,
-        torch_dtype=torch.float16,
-        device_map="auto"
-    )
-    tokenizer = AutoTokenizer.from_pretrained(model_name, revision=revision)
-    
-    # Tokenize the text
-    inputs = tokenizer(test_text, return_tensors="pt")
-    
-    # Move to same device as model
-    inputs = {k: v.to(model.device) for k, v in inputs.items()}
-    
-    # Calculate loss
-    with torch.no_grad():
-        outputs = model(**inputs, labels=inputs["input_ids"])
-        loss = outputs.loss
-    
-    # Calculate perplexity
-    perplexity = torch.exp(loss).item()
-    
-    return perplexity
+    try:
+        sys.stderr.write(f"Loading model: {model_name} (revision: {revision})\n")
+        sys.stderr.flush()
+        
+        # Default test text if none provided
+        if test_text is None:
+            test_text = """Artificial intelligence has transformed the way we live and work, bringing both opportunities and challenges. 
+            From autonomous vehicles to language models that can engage in human-like conversation, AI technologies are becoming increasingly 
+            sophisticated. However, with this advancement comes the responsibility to ensure these systems are developed and deployed ethically, 
+            with careful consideration for privacy, fairness, and transparency. The future of AI will likely depend on how well we balance innovation 
+            with these important social considerations."""
+        
+        sys.stderr.write("Loading tokenizer...\n")
+        sys.stderr.flush()
+        # Load tokenizer first
+        tokenizer = AutoTokenizer.from_pretrained(model_name, revision=revision)
+        sys.stderr.write("Tokenizer loaded successfully\n")
+        sys.stderr.flush()
+        
+        sys.stderr.write("Loading model...\n")
+        sys.stderr.flush()
+        # Load model
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name, 
+            revision=revision,
+            torch_dtype=torch.float16,
+            device_map="auto"
+        )
+        sys.stderr.write("Model loaded successfully\n")
+        sys.stderr.flush()
+        
+        sys.stderr.write("Tokenizing input text...\n")
+        sys.stderr.flush()
+        # Tokenize the text
+        inputs = tokenizer(test_text, return_tensors="pt")
+        sys.stderr.write(f"Tokenized input shape: {inputs['input_ids'].shape}\n")
+        sys.stderr.flush()
+        
+        # Move to same device as model
+        inputs = {k: v.to(model.device) for k, v in inputs.items()}
+        sys.stderr.write(f"Moved inputs to device: {model.device}\n")
+        sys.stderr.flush()
+        
+        sys.stderr.write("Running forward pass...\n")
+        sys.stderr.flush()
+        # Calculate loss
+        with torch.no_grad():
+            outputs = model(**inputs, labels=inputs["input_ids"])
+            loss = outputs.loss
+        
+        sys.stderr.write(f"Calculated loss: {loss.item()}\n")
+        sys.stderr.flush()
+        
+        # Calculate perplexity
+        perplexity = torch.exp(loss).item()
+        sys.stderr.write(f"Final perplexity: {perplexity}\n")
+        sys.stderr.flush()
+        
+        return perplexity
+        
+    except Exception as e:
+        import traceback
+        sys.stderr.write(f"Error in evaluate_perplexity: {e}\n")
+        sys.stderr.write(f"Traceback: {traceback.format_exc()}\n")
+        sys.stderr.flush()
+        raise
 
 def create_perplexity_result(model_name, revision, precision, perplexity_score):
     """

src/leaderboard/read_evals.py

@@ -76,8 +76,11 @@ class EvalResult:
 
     def to_dict(self):
         """Converts the Eval Result to a dict compatible with our dataframe display"""
-        print(f"\nProcessing result for model: {self.full_model}", flush=True)
-        print(f"Raw results: {self.results}", flush=True)
+        import sys
+        
+        sys.stderr.write(f"\nProcessing result for model: {self.full_model}\n")
+        sys.stderr.write(f"Raw results: {self.results}\n")
+        sys.stderr.flush()
         
         # Calculate average, handling perplexity (lower is better)
         scores = []
@@ -93,7 +96,8 @@ class EvalResult:
                 scores.append(score)
         
         average = sum(scores) / len(scores) if scores else 0
-        print(f"Calculated average score: {average}", flush=True)
+        sys.stderr.write(f"Calculated average score: {average}\n")
+        sys.stderr.flush()
         
         data_dict = {
             "eval_name": self.eval_name,  # not a column, just a save name,
@@ -115,17 +119,24 @@ class EvalResult:
         # Add perplexity score with the exact column name from Tasks
         if perplexity_score is not None:
             data_dict[Tasks.task0.value.col_name] = perplexity_score
-            print(f"Added perplexity score {perplexity_score} under column {Tasks.task0.value.col_name}", flush=True)
+            sys.stderr.write(f"Added perplexity score {perplexity_score} under column {Tasks.task0.value.col_name}\n")
+            sys.stderr.flush()
         else:
             data_dict[Tasks.task0.value.col_name] = None
-            print(f"No perplexity score found for column {Tasks.task0.value.col_name}", flush=True)
+            sys.stderr.write(f"No perplexity score found for column {Tasks.task0.value.col_name}\n")
+            sys.stderr.flush()
 
-        print(f"Final data dict keys: {list(data_dict.keys())}", flush=True)
+        sys.stderr.write(f"Final data dict keys: {list(data_dict.keys())}\n")
+        sys.stderr.flush()
         return data_dict
 
 def get_raw_eval_results(results_path: str) -> list[EvalResult]:
     """From the path of the results folder root, extract all perplexity results"""
-    print(f"\nSearching for result files in: {results_path}", flush=True)
+    import sys
+    
+    sys.stderr.write(f"\nSearching for result files in: {results_path}\n")
+    sys.stderr.flush()
+    
     model_result_filepaths = []
 
     for root, _, files in os.walk(results_path):
@@ -136,39 +147,55 @@ def get_raw_eval_results(results_path: str) -> list[EvalResult]:
         for file in files:
             model_result_filepaths.append(os.path.join(root, file))
 
-    print(f"Found {len(model_result_filepaths)} result files", flush=True)
+    sys.stderr.write(f"Found {len(model_result_filepaths)} result files\n")
+    sys.stderr.flush()
 
     eval_results = {}
     for model_result_filepath in model_result_filepaths:
         try:
-            print(f"\nProcessing file: {model_result_filepath}", flush=True)
+            sys.stderr.write(f"\nProcessing file: {model_result_filepath}\n")
+            sys.stderr.flush()
             # Creation of result
             eval_result = EvalResult.init_from_json_file(model_result_filepath)
-            print(f"Created result object for: {eval_result.full_model}", flush=True)
+            sys.stderr.write(f"Created result object for: {eval_result.full_model}\n")
+            sys.stderr.flush()
 
             # Store results of same eval together
             eval_name = eval_result.eval_name
             if eval_name in eval_results.keys():
                 eval_results[eval_name].results.update({k: v for k, v in eval_result.results.items() if v is not None})
-                print(f"Updated existing result for {eval_name}", flush=True)
+                sys.stderr.write(f"Updated existing result for {eval_name}\n")
+                sys.stderr.flush()
             else:
                 eval_results[eval_name] = eval_result
-                print(f"Added new result for {eval_name}", flush=True)
+                sys.stderr.write(f"Added new result for {eval_name}\n")
+                sys.stderr.flush()
         except Exception as e:
-            print(f"Error processing result file {model_result_filepath}: {e}", flush=True)
+            sys.stderr.write(f"Error processing result file {model_result_filepath}: {e}\n")
+            import traceback
+            sys.stderr.write(f"Traceback: {traceback.format_exc()}\n")
+            sys.stderr.flush()
             continue
 
     results = []
-    print(f"\nProcessing {len(eval_results)} evaluation results", flush=True)
+    sys.stderr.write(f"\nProcessing {len(eval_results)} evaluation results\n")
+    sys.stderr.flush()
+    
     for v in eval_results.values():
         try:
-            print(f"\nConverting result to dict for: {v.full_model}", flush=True)
+            sys.stderr.write(f"\nConverting result to dict for: {v.full_model}\n")
+            sys.stderr.flush()
             v.to_dict() # we test if the dict version is complete
             results.append(v)
-            print("Successfully converted and added result", flush=True)
+            sys.stderr.write("Successfully converted and added result\n")
+            sys.stderr.flush()
         except KeyError as e:
-            print(f"Error converting result to dict: {e}", flush=True)
+            sys.stderr.write(f"Error converting result to dict: {e}\n")
+            import traceback
+            sys.stderr.write(f"Traceback: {traceback.format_exc()}\n")
+            sys.stderr.flush()
             continue
 
-    print(f"\nReturning {len(results)} processed results", flush=True)
+    sys.stderr.write(f"\nReturning {len(results)} processed results\n")
+    sys.stderr.flush()
     return results

src/populate.py

@@ -1,60 +1,97 @@
 import pandas as pd
+import sys
 from src.display.formatting import has_no_nan_values, make_clickable_model
 from src.display.utils import AutoEvalColumn
 from src.leaderboard.read_evals import get_raw_eval_results
 
 def get_leaderboard_df(results_path: str, cols: list, benchmark_cols: list) -> pd.DataFrame:
     """Creates a dataframe from all the individual experiment results"""
-    print("\n=== Starting leaderboard creation ===", flush=True)
-    print(f"Looking for results in: {results_path}", flush=True)
-    print(f"Expected columns: {cols}", flush=True)
-    print(f"Benchmark columns: {benchmark_cols}", flush=True)
+    try:
+        sys.stderr.write("\n=== Starting leaderboard creation ===\n")
+        sys.stderr.write(f"Looking for results in: {results_path}\n")
+        sys.stderr.write(f"Expected columns: {cols}\n")
+        sys.stderr.write(f"Benchmark columns: {benchmark_cols}\n")
+        sys.stderr.flush()
 
-    raw_data = get_raw_eval_results(results_path)
-    print(f"\nFound {len(raw_data)} raw results", flush=True)
+        raw_data = get_raw_eval_results(results_path)
+        sys.stderr.write(f"\nFound {len(raw_data)} raw results\n")
+        sys.stderr.flush()
 
-    all_data_json = [v.to_dict() for v in raw_data]
-    print(f"\nConverted to {len(all_data_json)} JSON records", flush=True)
-    if all_data_json:
-        print("Sample record keys:", list(all_data_json[0].keys()), flush=True)
+        all_data_json = []
+        for i, v in enumerate(raw_data):
+            try:
+                data_dict = v.to_dict()
+                all_data_json.append(data_dict)
+                sys.stderr.write(f"Successfully processed result {i+1}/{len(raw_data)}: {v.full_model}\n")
+                sys.stderr.flush()
+            except Exception as e:
+                sys.stderr.write(f"Error processing result {i+1}/{len(raw_data)} ({v.full_model}): {e}\n")
+                sys.stderr.flush()
+                continue
+        
+        sys.stderr.write(f"\nConverted to {len(all_data_json)} JSON records\n")
+        sys.stderr.flush()
+        
+        if all_data_json:
+            sys.stderr.write("Sample record keys: " + str(list(all_data_json[0].keys())) + "\n")
+            sys.stderr.flush()
 
-    if not all_data_json:
-        print("\nNo data found, creating empty DataFrame", flush=True)
-        empty_df = pd.DataFrame(columns=cols)
-        # Ensure correct column types
-        empty_df[AutoEvalColumn.average.name] = pd.Series(dtype=float)
-        for col in benchmark_cols:
-            empty_df[col] = pd.Series(dtype=float)
-        return empty_df
+        if not all_data_json:
+            sys.stderr.write("\nNo data found, creating empty DataFrame\n")
+            sys.stderr.flush()
+            empty_df = pd.DataFrame(columns=cols)
+            # Ensure correct column types
+            empty_df[AutoEvalColumn.average.name] = pd.Series(dtype=float)
+            for col in benchmark_cols:
+                empty_df[col] = pd.Series(dtype=float)
+            return empty_df
 
-    df = pd.DataFrame.from_records(all_data_json)
-    print("\nCreated DataFrame with columns:", df.columns.tolist(), flush=True)
-    print("DataFrame shape:", df.shape, flush=True)
+        df = pd.DataFrame.from_records(all_data_json)
+        sys.stderr.write("\nCreated DataFrame with columns: " + str(df.columns.tolist()) + "\n")
+        sys.stderr.write("DataFrame shape: " + str(df.shape) + "\n")
+        sys.stderr.flush()
 
-    try:
-        df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
-        print("\nSorted DataFrame by average", flush=True)
-    except KeyError as e:
-        print(f"\nError sorting DataFrame: {e}", flush=True)
-        print("Available columns:", df.columns.tolist(), flush=True)
+        try:
+            df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
+            sys.stderr.write("\nSorted DataFrame by average\n")
+            sys.stderr.flush()
+        except KeyError as e:
+            sys.stderr.write(f"\nError sorting DataFrame: {e}\n")
+            sys.stderr.write("Available columns: " + str(df.columns.tolist()) + "\n")
+            sys.stderr.flush()
 
-    try:
-        df = df[cols].round(decimals=2)
-        print("\nSelected and rounded columns", flush=True)
-    except KeyError as e:
-        print(f"\nError selecting columns: {e}", flush=True)
-        print("Requested columns:", cols, flush=True)
-        print("Available columns:", df.columns.tolist(), flush=True)
-        # Create empty DataFrame with correct structure
+        try:
+            df = df[cols].round(decimals=2)
+            sys.stderr.write("\nSelected and rounded columns\n")
+            sys.stderr.flush()
+        except KeyError as e:
+            sys.stderr.write(f"\nError selecting columns: {e}\n")
+            sys.stderr.write("Requested columns: " + str(cols) + "\n")
+            sys.stderr.write("Available columns: " + str(df.columns.tolist()) + "\n")
+            sys.stderr.flush()
+            # Create empty DataFrame with correct structure
+            empty_df = pd.DataFrame(columns=cols)
+            empty_df[AutoEvalColumn.average.name] = pd.Series(dtype=float)
+            for col in benchmark_cols:
+                empty_df[col] = pd.Series(dtype=float)
+            return empty_df
+
+        # filter out if perplexity hasn't been evaluated
+        df = df[has_no_nan_values(df, benchmark_cols)]
+        sys.stderr.write("\nFinal DataFrame shape after filtering: " + str(df.shape) + "\n")
+        sys.stderr.write("Final columns: " + str(df.columns.tolist()) + "\n")
+        sys.stderr.flush()
+        
+        return df
+        
+    except Exception as e:
+        sys.stderr.write(f"\nCritical error in get_leaderboard_df: {e}\n")
+        import traceback
+        sys.stderr.write(f"Traceback: {traceback.format_exc()}\n")
+        sys.stderr.flush()
+        # Return empty DataFrame as fallback
         empty_df = pd.DataFrame(columns=cols)
         empty_df[AutoEvalColumn.average.name] = pd.Series(dtype=float)
         for col in benchmark_cols:
             empty_df[col] = pd.Series(dtype=float)
         return empty_df
-
-    # filter out if perplexity hasn't been evaluated
-    df = df[has_no_nan_values(df, benchmark_cols)]
-    print("\nFinal DataFrame shape after filtering:", df.shape, flush=True)
-    print("Final columns:", df.columns.tolist(), flush=True)
-    
-    return df