Update 'Open Model Accuracy by Size' plot to match Cost/Performance style

- Add Pareto efficiency frontier line (dashed yellow)
- Use uniform logo sizes instead of parameter-based scaling
- Show model name labels only for frontier points
- Remove 'logo size indicates parameter count' annotation
- Update description text to remove marker size reference

main_page.py

@@ -65,7 +65,7 @@ def build_page():
         
         # Open Model Accuracy by Size Section
         gr.HTML('<h2>Open Model Accuracy by Size</h2>', elem_id="size-accuracy-header")
-        gr.Markdown("Compare open-weights model performance against their parameter count. Marker size indicates total parameters; x-axis shows active parameters (relevant for MoE models).")
+        gr.Markdown("Compare open-weights model performance against their parameter count. The x-axis shows active parameters (relevant for MoE models).")
         
         size_fig = create_accuracy_by_size_chart(test_df)
         gr.Plot(value=size_fig, elem_id="size-accuracy-chart")

visualizations.py

@@ -343,7 +343,8 @@ def create_evolution_over_time_chart(df: pd.DataFrame) -> go.Figure:
 def create_accuracy_by_size_chart(df: pd.DataFrame) -> go.Figure:
     """
     Create a scatter plot showing accuracy vs parameter count for open-weights models.
-    Uses company logos as markers to match the existing chart styling.
+    Uses company logos as markers to match the Cost/Performance chart styling.
+    Includes a Pareto efficiency frontier line.
     
     Args:
         df: DataFrame with columns including 'parameter_count_b' or 'Parameter_Count_B', 
@@ -436,12 +437,7 @@ def create_accuracy_by_size_chart(df: pd.DataFrame) -> go.Figure:
     fig = go.Figure()
     
     # Prepare data for plotting
-    x_values = []
-    y_values = []
-    hover_texts = []
-    model_names = []
-    total_params_list = []
-    
+    data_points = []
     for _, row in plot_df.iterrows():
         total_params = row[param_col]
         active_params = row.get(active_param_col) if active_param_col else None
@@ -451,11 +447,6 @@ def create_accuracy_by_size_chart(df: pd.DataFrame) -> go.Figure:
         # Use active params for x-axis if available (more meaningful for MoE)
         x_val = active_params if pd.notna(active_params) else total_params
         
-        x_values.append(x_val)
-        y_values.append(score)
-        model_names.append(model_name)
-        total_params_list.append(total_params)
-        
         # Create hover text matching existing chart style
         h_pad = "   "
         hover_text = f"<br>{h_pad}<b>{model_name}</b>{h_pad}<br>"
@@ -463,7 +454,17 @@ def create_accuracy_by_size_chart(df: pd.DataFrame) -> go.Figure:
         if pd.notna(active_params):
             hover_text += f"{h_pad}Active Params: <b>{active_params:.0f}B</b>{h_pad}<br>"
         hover_text += f"{h_pad}Average Score: <b>{score:.1f}</b>{h_pad}<br>"
-        hover_texts.append(hover_text)
+        
+        data_points.append({
+            'x': x_val,
+            'y': score,
+            'model_name': model_name,
+            'hover_text': hover_text,
+            'total_params': total_params
+        })
+    
+    x_values = [p['x'] for p in data_points]
+    y_values = [p['y'] for p in data_points]
     
     # Calculate axis ranges for domain coordinate conversion
     min_x = min(x_values)
@@ -474,7 +475,33 @@ def create_accuracy_by_size_chart(df: pd.DataFrame) -> go.Figure:
     min_score = min(y_values)
     max_score = max(y_values)
     y_min = min_score - 5 if min_score > 5 else 0
-    y_max = max_score + 10  # Extra space for labels
+    y_max = max_score + 5
+    
+    # Calculate and draw Pareto Efficiency Frontier
+    # For size vs accuracy, we want: smaller size (lower x) AND higher accuracy (higher y)
+    # Sort by x ascending, then track maximum y seen
+    sorted_data = sorted(data_points, key=lambda p: (p['x'], -p['y']))
+    frontier_points = []
+    frontier_rows = []
+    max_score_so_far = float('-inf')
+    
+    for point in sorted_data:
+        if point['y'] >= max_score_so_far:
+            frontier_points.append({'x': point['x'], 'y': point['y']})
+            frontier_rows.append(point)
+            max_score_so_far = point['y']
+    
+    if frontier_points:
+        frontier_df = pd.DataFrame(frontier_points)
+        fig.add_trace(go.Scatter(
+            x=frontier_df['x'],
+            y=frontier_df['y'],
+            mode='lines',
+            name='Efficiency Frontier',
+            showlegend=False,
+            line=dict(color='#FFE165', width=2, dash='dash'),  # primary yellow
+            hoverinfo='skip'
+        ))
     
     # Add invisible markers for hover functionality
     fig.add_trace(go.Scatter(
@@ -483,7 +510,7 @@ def create_accuracy_by_size_chart(df: pd.DataFrame) -> go.Figure:
         mode='markers',
         name='Models',
         showlegend=False,
-        text=hover_texts,
+        text=[p['hover_text'] for p in data_points],
         hoverinfo='text',
         marker=dict(
             color='rgba(0,0,0,0)',  # Invisible markers
@@ -492,11 +519,14 @@ def create_accuracy_by_size_chart(df: pd.DataFrame) -> go.Figure:
         )
     ))
     
-    # Add company logo images for each data point
+    # Add company logo images for each data point (uniform size like Cost/Performance chart)
     layout_images = []
-    frontier_labels_data = []
     
-    for i, (x_val, y_val, model_name, total_params) in enumerate(zip(x_values, y_values, model_names, total_params_list)):
+    for point in data_points:
+        x_val = point['x']
+        y_val = point['y']
+        model_name = point['model_name']
+        
         company_info = get_company_from_model(model_name)
         logo_path = company_info['path']
         
@@ -517,43 +547,48 @@ def create_accuracy_by_size_chart(df: pd.DataFrame) -> go.Figure:
                     domain_y = (y_val - y_min) / (y_max - y_min) if (y_max - y_min) > 0 else 0.5
                     
                     # Clamp to valid range
-                    domain_x = max(0.02, min(0.98, domain_x))
-                    domain_y = max(0.02, min(0.98, domain_y))
-                    
-                    # Scale logo size based on total params
-                    size_scale = 0.03 + (total_params / 2000)  # Larger models = larger logos
-                    size_scale = min(size_scale, 0.06)  # Cap size
+                    domain_x = max(0, min(1, domain_x))
+                    domain_y = max(0, min(1, domain_y))
                     
+                    # Uniform logo size (same as Cost/Performance chart)
                     layout_images.append(dict(
                         source=logo_uri,
                         xref="x domain",
                         yref="y domain",
                         x=domain_x,
                         y=domain_y,
-                        sizex=size_scale,
-                        sizey=size_scale * 1.5,
+                        sizex=0.04,  # Size as fraction of plot width
+                        sizey=0.06,  # Size as fraction of plot height
                         xanchor="center",
                         yanchor="middle",
                         layer="above"
                     ))
-                    
-                    # Store label data for annotation
-                    frontier_labels_data.append({
-                        'x': domain_x,
-                        'y': domain_y,
-                        'label': model_name
-                    })
             except Exception:
                 pass
     
-    # Add model name labels above each point
-    for item in frontier_labels_data:
+    # Add model name labels for frontier points only (like Cost/Performance chart)
+    for point in frontier_rows:
+        x_val = point['x']
+        y_val = point['y']
+        model_name = point['model_name']
+        
+        # Clean model name for label
+        if isinstance(model_name, list):
+            model_name = model_name[0] if model_name else ''
+        model_name = str(model_name).split('/')[-1]
+        if len(model_name) > 25:
+            model_name = model_name[:22] + '...'
+        
+        # Transform x to log10 for annotation positioning on log scale
+        if x_val > 0:
+            x_log = np.log10(x_val)
+        else:
+            x_log = x_min_log
+        
         fig.add_annotation(
-            x=item['x'],
-            y=item['y'],
-            xref="x domain",
-            yref="y domain",
-            text=item['label'],
+            x=x_log,
+            y=y_val,
+            text=model_name,
             showarrow=False,
             yshift=25,
             font=STANDARD_FONT,
@@ -582,16 +617,6 @@ def create_accuracy_by_size_chart(df: pd.DataFrame) -> go.Figure:
     
     fig.update_layout(**layout_config)
     
-    # Add annotation explaining marker size
-    fig.add_annotation(
-        text="Logo size indicates total parameter count",
-        xref="paper", yref="paper",
-        x=0.02, y=-0.08,
-        showarrow=False,
-        font=STANDARD_FONT,
-        align='left'
-    )
-    
     # Add OpenHands branding
     add_branding_to_figure(fig)