Update app.py

app.py

@@ -117,20 +117,50 @@ def init_leaderboard_mib(dataframe, track):
     )
 
 
-def init_leaderboard_mib_causal(json_data, track):
-    """Creates a leaderboard summary for causal intervention results"""
+def calculate_best_layer_scores(task_data: Dict[str, Any]) -> Dict[str, float]:
+    """
+    Calculate the best scores across layers for output token and location
     
-    # Process results into summary format
-    summary_data = []
+    Args:
+        task_data: Dictionary containing task scores for different layers
+        
+    Returns:
+        Dictionary with best scores and corresponding layer
+    """
+    output_token_scores = [layer_data['output_token'] for layer_data in task_data.values()]
+    output_location_scores = [layer_data['output_location'] for layer_data in task_data.values()]
+    
+    best_output_token = max(output_token_scores)
+    best_output_location = max(output_location_scores)
+    
+    # Find the layer with the best combined performance
+    layer_scores = [(layer, layer_data['output_token'] + layer_data['output_location']) 
+                   for layer, layer_data in task_data.items()]
+    best_layer = max(layer_scores, key=lambda x: x[1])[0]
+    
+    return {
+        'output_token': best_output_token,
+        'output_location': best_output_location,
+        'best_layer': int(best_layer)
+    }
+
+def process_single_method(json_data: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Process results for a single method into summary rows
     
+    Args:
+        json_data: Dictionary containing results for one method
+        
+    Returns:
+        List of summary rows for the method
+    """
+    summary_rows = []
     method_name = json_data['method_name']
     
-    # Extract scores for MCQA task
     for model_result in json_data['results']:
         model_id = model_result['model_id']
         task_data = model_result['task_scores']['MCQA']
         
-        # Calculate best layer performance
         best_scores = calculate_best_layer_scores(task_data)
         
         summary_row = {
@@ -140,10 +170,32 @@ def init_leaderboard_mib_causal(json_data, track):
             'Best Output Location Score': best_scores['output_location'],
             'Best Layer': best_scores['best_layer']
         }
-        summary_data.append(summary_row)
+        summary_rows.append(summary_row)
+    
+    return summary_rows
+
+def init_leaderboard_mib_causal(json_data_list: List[Dict[str, Any]], track: str) -> 'Leaderboard':
+    """
+    Creates a leaderboard summary for causal intervention results from multiple methods
+    
+    Args:
+        json_data_list: List of dictionaries containing results for different methods
+        track: Track identifier (currently unused but maintained for compatibility)
+        
+    Returns:
+        Leaderboard object containing processed and formatted results
+    """
+    # Process all methods
+    all_summary_data = []
+    for method_data in json_data_list:
+        method_summary = process_single_method(method_data)
+        all_summary_data.extend(method_summary)
     
     # Convert to DataFrame
-    results_df = pd.DataFrame(summary_data)
+    results_df = pd.DataFrame(all_summary_data)
+    
+    # Sort by best score (using output token score as primary metric)
+    results_df = results_df.sort_values('Best Output Token Score', ascending=False)
     
     # Round numeric columns to 3 decimal places
     numeric_cols = ['Best Output Token Score', 'Best Output Location Score']
@@ -161,32 +213,6 @@ def init_leaderboard_mib_causal(json_data, track):
         interactive=False,
     )
 
-def calculate_best_layer_scores(task_data):
-    """Calculate the best scores across all layers for each intervention type"""
-    best_output_token = 0
-    best_output_location = 0
-    best_layer = 0
-    
-    for layer_data in task_data:
-        layer_num = int(layer_data['layer'])
-        layer_scores = layer_data['layer_scores']
-        
-        # Calculate average scores for each intervention type
-        output_token_avg = sum(cf['score'] for cf in layer_scores[0]['counterfactual_scores']) / len(layer_scores[0]['counterfactual_scores'])
-        output_location_avg = sum(cf['score'] for cf in layer_scores[1]['counterfactual_scores']) / len(layer_scores[1]['counterfactual_scores'])
-        
-        # Update best scores
-        if output_token_avg > best_output_token or output_location_avg > best_output_location:
-            best_output_token = max(best_output_token, output_token_avg)
-            best_output_location = max(best_output_location, output_location_avg)
-            best_layer = layer_num
-    
-    return {
-        'output_token': best_output_token,
-        'output_location': best_output_location,
-        'best_layer': best_layer
-    }
-
 def init_leaderboard(dataframe, track):
     if dataframe is None or dataframe.empty:
         raise ValueError("Leaderboard DataFrame is empty or None.")