Update src/plotting.py

src/plotting.py

@@ -38,86 +38,121 @@ def create_leaderboard_plot(
         )
         return fig
     
-    # Get top N models for this track
-    metric_col = f"{track}_{metric}"
-    ci_lower_col = f"{track}_ci_lower"
-    ci_upper_col = f"{track}_ci_upper"
-    
-    if metric_col not in df.columns:
+    try:
+        # Get top N models for this track
+        metric_col = f"{track}_{metric}"
+        ci_lower_col = f"{track}_ci_lower"
+        ci_upper_col = f"{track}_ci_upper"
+        
+        if metric_col not in df.columns:
+            fig = go.Figure()
+            fig.add_annotation(
+                text=f"Metric {metric} not available for {track} track",
+                xref="paper", yref="paper",
+                x=0.5, y=0.5, showarrow=False,
+            )
+            return fig
+        
+        # Ensure numeric columns are properly typed
+        numeric_cols = [metric_col, ci_lower_col, ci_upper_col]
+        for col in numeric_cols:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0.0)
+        
+        # Filter and sort
+        valid_models = df[(df[metric_col] > 0)].head(top_n).copy()
+        
+        if valid_models.empty:
+            fig = go.Figure()
+            fig.add_annotation(text="No valid models found", x=0.5, y=0.5, showarrow=False)
+            return fig
+        
+        # Create color mapping by category
+        colors = [MODEL_CATEGORIES.get(cat, {}).get("color", "#808080") for cat in valid_models["model_category"]]
+        
+        # Main bar plot
         fig = go.Figure()
-        fig.add_annotation(
-            text=f"Metric {metric} not available for {track} track",
-            xref="paper", yref="paper",
-            x=0.5, y=0.5, showarrow=False,
+        
+        # Add bars with error bars if confidence intervals available
+        error_x = None
+        if ci_lower_col in valid_models.columns and ci_upper_col in valid_models.columns:
+            try:
+                error_x = dict(
+                    type="data",
+                    array=valid_models[ci_upper_col] - valid_models[metric_col],
+                    arrayminus=valid_models[metric_col] - valid_models[ci_lower_col],
+                    visible=True,
+                    thickness=2,
+                    width=4,
+                )
+            except Exception as e:
+                print(f"Error creating error bars: {e}")
+                error_x = None
+        
+        # Safely format text values
+        try:
+            text_values = [f"{float(score):.3f}" for score in valid_models[metric_col]]
+        except:
+            text_values = ["0.000"] * len(valid_models)
+        
+        # Safely prepare custom data
+        try:
+            samples_col = f"{track}_samples"
+            samples_data = valid_models.get(samples_col, [0] * len(valid_models))
+            customdata = list(zip(
+                valid_models["model_category"].fillna("unknown"),
+                valid_models["author"].fillna("Anonymous"),
+                [int(float(x)) if pd.notnull(x) else 0 for x in samples_data]
+            ))
+        except Exception as e:
+            print(f"Error preparing custom data: {e}")
+            customdata = [("unknown", "Anonymous", 0)] * len(valid_models)
+        
+        fig.add_trace(go.Bar(
+            y=valid_models["model_name"],
+            x=valid_models[metric_col],
+            orientation="h",
+            marker=dict(color=colors, line=dict(color="black", width=0.5)),
+            error_x=error_x,
+            text=text_values,
+            textposition="auto",
+            hovertemplate=(
+                "<b>%{y}</b><br>" +
+                f"{metric.title()}: %{{x:.4f}}<br>" +
+                "Category: %{customdata[0]}<br>" +
+                "Author: %{customdata[1]}<br>" +
+                "Samples: %{customdata[2]}<br>" +
+                "<extra></extra>"
+            ),
+            customdata=customdata,
+        ))
+        
+        # Customize layout
+        track_info = EVALUATION_TRACKS[track]
+        fig.update_layout(
+            title=f"🏆 {track_info['name']} - {metric.title()} Score",
+            xaxis_title=f"{metric.title()} Score (with 95% CI)",
+            yaxis_title="Models",
+            height=max(400, len(valid_models) * 35 + 100),
+            margin=dict(l=20, r=20, t=60, b=20),
+            paper_bgcolor="rgba(0,0,0,0)",
+            plot_bgcolor="rgba(0,0,0,0)",
+            font=dict(size=12),
         )
+        
+        # Reverse y-axis to show best model at top
+        fig.update_yaxes(autorange="reversed")
+        
         return fig
-    
-    # Filter and sort
-    valid_models = df[(df[metric_col] > 0)].head(top_n)
-    
-    if valid_models.empty:
+        
+    except Exception as e:
+        print(f"Error creating leaderboard plot: {e}")
         fig = go.Figure()
-        fig.add_annotation(text="No valid models found", x=0.5, y=0.5, showarrow=False)
-        return fig
-    
-    # Create color mapping by category
-    colors = [MODEL_CATEGORIES.get(cat, {}).get("color", "#808080") for cat in valid_models["model_category"]]
-    
-    # Main bar plot
-    fig = go.Figure()
-    
-    # Add bars with error bars if confidence intervals available
-    error_x = None
-    if ci_lower_col in valid_models.columns and ci_upper_col in valid_models.columns:
-        error_x = dict(
-            type="data",
-            array=valid_models[ci_upper_col] - valid_models[metric_col],
-            arrayminus=valid_models[metric_col] - valid_models[ci_lower_col],
-            visible=True,
-            thickness=2,
-            width=4,
+        fig.add_annotation(
+            text=f"Error creating plot: {str(e)}",
+            x=0.5, y=0.5, showarrow=False
         )
-    
-    fig.add_trace(go.Bar(
-        y=valid_models["model_name"],
-        x=valid_models[metric_col],
-        orientation="h",
-        marker=dict(color=colors, line=dict(color="black", width=0.5)),
-        error_x=error_x,
-        text=[f"{score:.3f}" for score in valid_models[metric_col]],
-        textposition="auto",
-        hovertemplate=(
-            "<b>%{y}</b><br>" +
-            f"{metric.title()}: %{{x:.4f}}<br>" +
-            "Category: %{customdata[0]}<br>" +
-            "Author: %{customdata[1]}<br>" +
-            "Samples: %{customdata[2]}<br>" +
-            "<extra></extra>"
-        ),
-        customdata=list(zip(
-            valid_models["model_category"],
-            valid_models["author"],
-            valid_models.get(f"{track}_samples", [0] * len(valid_models))
-        )),
-    ))
-    
-    # Customize layout
-    track_info = EVALUATION_TRACKS[track]
-    fig.update_layout(
-        title=f"🏆 {track_info['name']} - {metric.title()} Score",
-        xaxis_title=f"{metric.title()} Score (with 95% CI)",
-        yaxis_title="Models",
-        height=max(400, len(valid_models) * 35 + 100),
-        margin=dict(l=20, r=20, t=60, b=20),
-        paper_bgcolor="rgba(0,0,0,0)",
-        plot_bgcolor="rgba(0,0,0,0)",
-        font=dict(size=12),
-    )
-    
-    # Reverse y-axis to show best model at top
-    fig.update_yaxes(autorange="reversed")
-    
-    return fig
+        return fig
 
 
 def create_language_pair_heatmap(
@@ -201,79 +236,112 @@ def create_performance_comparison_plot(df: pd.DataFrame, track: str) -> go.Figur
         fig.add_annotation(text="No data available", x=0.5, y=0.5, showarrow=False)
         return fig
     
-    metric_col = f"{track}_quality"
-    ci_lower_col = f"{track}_ci_lower"
-    ci_upper_col = f"{track}_ci_upper"
-    
-    # Filter to models with data for this track
-    valid_models = df[
-        (df[metric_col] > 0) & 
-        (df[ci_lower_col].notna()) & 
-        (df[ci_upper_col].notna())
-    ].head(10)
-    
-    if valid_models.empty:
+    try:
+        metric_col = f"{track}_quality"
+        ci_lower_col = f"{track}_ci_lower"
+        ci_upper_col = f"{track}_ci_upper"
+        
+        # Ensure numeric columns are properly typed
+        numeric_cols = [metric_col, ci_lower_col, ci_upper_col]
+        for col in numeric_cols:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce').fillna(0.0)
+        
+        # Filter to models with data for this track
+        valid_models = df[
+            (df[metric_col] > 0) & 
+            (df[ci_lower_col].notna()) & 
+            (df[ci_upper_col].notna())
+        ].head(10).copy()
+        
+        if valid_models.empty:
+            fig = go.Figure()
+            fig.add_annotation(text="No models with confidence intervals", x=0.5, y=0.5, showarrow=False)
+            return fig
+        
         fig = go.Figure()
-        fig.add_annotation(text="No models with confidence intervals", x=0.5, y=0.5, showarrow=False)
-        return fig
-    
-    fig = go.Figure()
-    
-    # Add confidence intervals as error bars
-    for i, (_, model) in enumerate(valid_models.iterrows()):
-        category = model["model_category"]
-        color = MODEL_CATEGORIES.get(category, {}).get("color", "#808080")
         
-        # Main point
-        fig.add_trace(go.Scatter(
-            x=[model[metric_col]],
-            y=[i],
-            mode="markers",
-            marker=dict(
-                size=12,
-                color=color,
-                line=dict(color="black", width=1),
+        # Add confidence intervals as error bars
+        for i, (_, model) in enumerate(valid_models.iterrows()):
+            try:
+                category = str(model["model_category"])
+                color = MODEL_CATEGORIES.get(category, {}).get("color", "#808080")
+                model_name = str(model["model_name"])
+                
+                # Safely extract numeric values
+                quality_val = float(model[metric_col])
+                ci_lower_val = float(model[ci_lower_col])
+                ci_upper_val = float(model[ci_upper_col])
+                
+                # Main point
+                fig.add_trace(go.Scatter(
+                    x=[quality_val],
+                    y=[i],
+                    mode="markers",
+                    marker=dict(
+                        size=12,
+                        color=color,
+                        line=dict(color="black", width=1),
+                    ),
+                    name=model_name,
+                    showlegend=False,
+                    hovertemplate=(
+                        f"<b>{model_name}</b><br>" +
+                        f"Quality: {quality_val:.4f}<br>" +
+                        f"95% CI: [{ci_lower_val:.4f}, {ci_upper_val:.4f}]<br>" +
+                        f"Category: {category}<br>" +
+                        "<extra></extra>"
+                    ),
+                ))
+                
+                # Confidence interval line
+                fig.add_trace(go.Scatter(
+                    x=[ci_lower_val, ci_upper_val],
+                    y=[i, i],
+                    mode="lines",
+                    line=dict(color=color, width=3),
+                    showlegend=False,
+                    hoverinfo="skip",
+                ))
+                
+            except Exception as e:
+                print(f"Error adding model {i} to comparison plot: {e}")
+                continue
+        
+        # Safely prepare tick labels
+        try:
+            tick_labels = [str(name) for name in valid_models["model_name"]]
+        except:
+            tick_labels = [f"Model {i}" for i in range(len(valid_models))]
+        
+        # Customize layout
+        track_info = EVALUATION_TRACKS[track]
+        fig.update_layout(
+            title=f"📊 {track_info['name']} - Performance Comparison",
+            xaxis_title="Quality Score",
+            yaxis_title="Models",
+            height=max(400, len(valid_models) * 40 + 100),
+            yaxis=dict(
+                tickmode="array",
+                tickvals=list(range(len(valid_models))),
+                ticktext=tick_labels,
+                autorange="reversed",
             ),
-            name=model["model_name"],
             showlegend=False,
-            hovertemplate=(
-                f"<b>{model['model_name']}</b><br>" +
-                f"Quality: {model[metric_col]:.4f}<br>" +
-                f"95% CI: [{model[ci_lower_col]:.4f}, {model[ci_upper_col]:.4f}]<br>" +
-                f"Category: {category}<br>" +
-                "<extra></extra>"
-            ),
-        ))
+            paper_bgcolor="rgba(0,0,0,0)",
+            plot_bgcolor="rgba(0,0,0,0)",
+        )
         
-        # Confidence interval line
-        fig.add_trace(go.Scatter(
-            x=[model[ci_lower_col], model[ci_upper_col]],
-            y=[i, i],
-            mode="lines",
-            line=dict(color=color, width=3),
-            showlegend=False,
-            hoverinfo="skip",
-        ))
-    
-    # Customize layout
-    track_info = EVALUATION_TRACKS[track]
-    fig.update_layout(
-        title=f"📊 {track_info['name']} - Performance Comparison",
-        xaxis_title="Quality Score",
-        yaxis_title="Models",
-        height=max(400, len(valid_models) * 40 + 100),
-        yaxis=dict(
-            tickmode="array",
-            tickvals=list(range(len(valid_models))),
-            ticktext=valid_models["model_name"].tolist(),
-            autorange="reversed",
-        ),
-        showlegend=False,
-        paper_bgcolor="rgba(0,0,0,0)",
-        plot_bgcolor="rgba(0,0,0,0)",
-    )
-    
-    return fig
+        return fig
+        
+    except Exception as e:
+        print(f"Error creating performance comparison plot: {e}")
+        fig = go.Figure()
+        fig.add_annotation(
+            text=f"Error creating plot: {str(e)}",
+            x=0.5, y=0.5, showarrow=False
+        )
+        return fig
 
 
 def create_language_pair_comparison_plot(pairs_df: pd.DataFrame, track: str) -> go.Figure: