Update src/plotting.py

src/plotting.py

@@ -1,7 +1,4 @@
 # src/plotting.py
-import json
-import matplotlib.pyplot as plt
-import matplotlib.gridspec as gridspec
 import plotly.graph_objects as go
 import plotly.express as px
 from plotly.subplots import make_subplots
@@ -18,25 +15,13 @@ from config import (
     EVALUATION_TRACKS,
     MODEL_CATEGORIES,
     CHART_CONFIG,
-    STATISTICAL_CONFIG,
-    SAMPLE_SIZE_RECOMMENDATIONS,
 )
 
-# Scientific plotting style
-plt.style.use("default")
-plt.rcParams["figure.facecolor"] = "white"
-plt.rcParams["axes.facecolor"] = "white"
-plt.rcParams["font.size"] = 10
-plt.rcParams["axes.labelsize"] = 12
-plt.rcParams["axes.titlesize"] = 14
-plt.rcParams["xtick.labelsize"] = 10
-plt.rcParams["ytick.labelsize"] = 10
-
 
-def create_scientific_leaderboard_plot(
+def create_leaderboard_plot(
     df: pd.DataFrame, track: str, metric: str = "quality", top_n: int = 15
 ) -> go.Figure:
-    """Create scientific leaderboard plot with confidence intervals."""
+    """Create leaderboard plot with confidence intervals."""
     
     if df.empty:
         fig = go.Figure()
@@ -46,7 +31,11 @@ def create_scientific_leaderboard_plot(
             x=0.5, y=0.5, showarrow=False,
             font=dict(size=16)
         )
-        fig.update_layout(title=f"No Data Available - {track.title()} Track")
+        fig.update_layout(
+            title=f"No Data Available - {track.title()} Track",
+            paper_bgcolor="rgba(0,0,0,0)",
+            plot_bgcolor="rgba(0,0,0,0)"
+        )
         return fig
     
     # Get top N models for this track
@@ -72,18 +61,15 @@ def create_scientific_leaderboard_plot(
         return fig
     
     # Create color mapping by category
-    category_colors = {}
-    for i, category in enumerate(MODEL_CATEGORIES.keys()):
-        category_colors[category] = MODEL_CATEGORIES[category]["color"]
-    
-    colors = [category_colors.get(cat, "#808080") for cat in valid_models["model_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_y = dict(
+        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],
@@ -91,15 +77,13 @@ def create_scientific_leaderboard_plot(
             thickness=2,
             width=4,
         )
-    else:
-        error_y = None
     
     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_y,
+        error_x=error_x,
         text=[f"{score:.3f}" for score in valid_models[metric_col]],
         textposition="auto",
         hovertemplate=(
@@ -125,32 +109,21 @@ def create_scientific_leaderboard_plot(
         yaxis_title="Models",
         height=max(400, len(valid_models) * 35 + 100),
         margin=dict(l=20, r=20, t=60, b=20),
-        plot_bgcolor="white",
-        paper_bgcolor="white",
+        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")
     
-    # Add category legend
-    for category, info in MODEL_CATEGORIES.items():
-        if category in valid_models["model_category"].values:
-            fig.add_trace(go.Scatter(
-                x=[None], y=[None],
-                mode="markers",
-                marker=dict(size=10, color=info["color"]),
-                name=info["name"],
-                showlegend=True,
-            ))
-    
     return fig
 
 
-def create_language_pair_heatmap_scientific(
+def create_language_pair_heatmap(
     model_results: Dict, track: str, metric: str = "quality_score"
 ) -> go.Figure:
-    """Create research-grade language pair heatmap with proper axes."""
+    """Create language pair heatmap for a model."""
     
     if not model_results or "tracks" not in model_results:
         fig = go.Figure()
@@ -212,14 +185,16 @@ def create_language_pair_heatmap_scientific(
         width=700,
         font=dict(size=12),
         xaxis=dict(side="bottom"),
-        yaxis=dict(autorange="reversed"),  # Source languages from top to bottom
+        yaxis=dict(autorange="reversed"),
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
     )
     
     return fig
 
 
-def create_statistical_comparison_plot(df: pd.DataFrame, track: str) -> go.Figure:
-    """Create statistical comparison plot showing confidence intervals."""
+def create_performance_comparison_plot(df: pd.DataFrame, track: str) -> go.Figure:
+    """Create performance comparison plot showing confidence intervals."""
     
     if df.empty:
         fig = go.Figure()
@@ -279,26 +254,11 @@ def create_statistical_comparison_plot(df: pd.DataFrame, track: str) -> go.Figur
             showlegend=False,
             hoverinfo="skip",
         ))
-        
-        # CI endpoints
-        fig.add_trace(go.Scatter(
-            x=[model[ci_lower_col], model[ci_upper_col]],
-            y=[i, i],
-            mode="markers",
-            marker=dict(
-                symbol="line-ns",
-                size=10,
-                color=color,
-                line=dict(width=2),
-            ),
-            showlegend=False,
-            hoverinfo="skip",
-        ))
     
     # Customize layout
     track_info = EVALUATION_TRACKS[track]
     fig.update_layout(
-        title=f"📊 {track_info['name']} - Statistical Comparison",
+        title=f"📊 {track_info['name']} - Performance Comparison",
         xaxis_title="Quality Score",
         yaxis_title="Models",
         height=max(400, len(valid_models) * 40 + 100),
@@ -309,371 +269,167 @@ def create_statistical_comparison_plot(df: pd.DataFrame, track: str) -> go.Figur
             autorange="reversed",
         ),
         showlegend=False,
-        plot_bgcolor="white",
-        paper_bgcolor="white",
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
     )
     
     return fig
 
 
-def create_category_comparison_plot(df: pd.DataFrame, track: str) -> go.Figure:
-    """Create category-wise comparison plot."""
+def create_language_pair_comparison_plot(pairs_df: pd.DataFrame, track: str) -> go.Figure:
+    """Create language pair comparison plot showing all models across all pairs."""
     
-    if df.empty:
+    if pairs_df.empty:
         fig = go.Figure()
-        fig.add_annotation(text="No data available", x=0.5, y=0.5, showarrow=False)
-        return fig
-    
-    metric_col = f"{track}_quality"
-    adequate_col = f"{track}_adequate"
-    
-    # Filter to adequate models
-    valid_models = df[df[adequate_col] & (df[metric_col] > 0)]
-    
-    if valid_models.empty:
-        fig = go.Figure()
-        fig.add_annotation(text="No adequate models found", x=0.5, y=0.5, showarrow=False)
+        fig.add_annotation(
+            text="No language pair data available", 
+            x=0.5, y=0.5, showarrow=False
+        )
         return fig
     
-    fig = go.Figure()
-    
-    # Create box plot for each category
-    for category, info in MODEL_CATEGORIES.items():
-        category_models = valid_models[valid_models["model_category"] == category]
-        
-        if len(category_models) > 0:
-            fig.add_trace(go.Box(
-                y=category_models[metric_col],
-                name=info["name"],
-                marker_color=info["color"],
-                boxpoints="all",  # Show all points
-                jitter=0.3,
-                pointpos=-1.8,
-                hovertemplate=(
-                    f"<b>{info['name']}</b><br>" +
-                    "Quality: %{y:.4f}<br>" +
-                    "Model: %{customdata}<br>" +
-                    "<extra></extra>"
-                ),
-                customdata=category_models["model_name"],
-            ))
-    
-    # Customize layout
-    track_info = EVALUATION_TRACKS[track]
-    fig.update_layout(
-        title=f"📈 {track_info['name']} - Performance by Category",
-        xaxis_title="Model Category",
-        yaxis_title="Quality Score",
-        height=500,
-        showlegend=False,
-        plot_bgcolor="white",
-        paper_bgcolor="white",
-    )
-    
-    return fig
-
-
-def create_adequacy_analysis_plot(df: pd.DataFrame) -> go.Figure:
-    """Create analysis plot for statistical adequacy across tracks."""
+    # Get unique language pairs and models
+    language_pairs = sorted(pairs_df['Language Pair'].unique())
+    models = sorted(pairs_df['Model'].unique())
     
-    if df.empty:
+    if len(language_pairs) == 0 or len(models) == 0:
         fig = go.Figure()
-        fig.add_annotation(text="No data available", x=0.5, y=0.5, showarrow=False)
+        fig.add_annotation(
+            text="Insufficient data for comparison", 
+            x=0.5, y=0.5, showarrow=False
+        )
         return fig
     
+    # Create subplot for each metric
     fig = make_subplots(
-        rows=2, cols=2,
-        subplot_titles=(
-            "Sample Sizes by Track",
-            "Statistical Adequacy Distribution", 
-            "Scientific Adequacy Scores",
-            "Model Categories Distribution"
-        ),
-        specs=[
-            [{"type": "bar"}, {"type": "pie"}],
-            [{"type": "histogram"}, {"type": "bar"}]
-        ]
+        rows=2, cols=1,
+        subplot_titles=('Quality Score by Language Pair', 'BLEU Score by Language Pair'),
+        vertical_spacing=0.1,
+        shared_xaxes=True
     )
     
-    # Sample sizes by track
-    track_names = []
-    sample_counts = []
-    
-    for track in EVALUATION_TRACKS.keys():
-        samples_col = f"{track}_samples"
-        if samples_col in df.columns:
-            total_samples = df[df[samples_col] > 0][samples_col].sum()
-            track_names.append(track.replace("_", " ").title())
-            sample_counts.append(total_samples)
-    
-    if track_names:
+    # Quality Score comparison
+    for model in models:
+        model_data = pairs_df[pairs_df['Model'] == model]
+        category = model_data['Category'].iloc[0] if not model_data.empty else 'community'
+        color = MODEL_CATEGORIES.get(category, {}).get('color', '#808080')
+        
         fig.add_trace(
-            go.Bar(x=track_names, y=sample_counts, name="Samples"),
+            go.Bar(
+                name=model,
+                x=model_data['Language Pair'],
+                y=model_data['Quality Score'],
+                marker_color=color,
+                opacity=0.8,
+                legendgroup=model,
+                showlegend=True,
+                hovertemplate=(
+                    f"<b>{model}</b><br>" +
+                    "Language Pair: %{x}<br>" +
+                    "Quality Score: %{y:.4f}<br>" +
+                    f"Category: {category}<br>" +
+                    "<extra></extra>"
+                )
+            ),
             row=1, col=1
         )
-    
-    # Statistical adequacy distribution
-    adequacy_bins = pd.cut(
-        df["scientific_adequacy_score"], 
-        bins=[0, 0.3, 0.6, 0.8, 1.0],
-        labels=["Poor", "Fair", "Good", "Excellent"]
-    )
-    adequacy_counts = adequacy_bins.value_counts()
-    
-    if not adequacy_counts.empty:
+        
+        # BLEU Score comparison
         fig.add_trace(
-            go.Pie(
-                labels=adequacy_counts.index,
-                values=adequacy_counts.values,
-                name="Adequacy"
+            go.Bar(
+                name=model,
+                x=model_data['Language Pair'],
+                y=model_data['BLEU'],
+                marker_color=color,
+                opacity=0.8,
+                legendgroup=model,
+                showlegend=False,
+                hovertemplate=(
+                    f"<b>{model}</b><br>" +
+                    "Language Pair: %{x}<br>" +
+                    "BLEU: %{y:.2f}<br>" +
+                    f"Category: {category}<br>" +
+                    "<extra></extra>"
+                )
             ),
-            row=1, col=2
+            row=2, col=1
         )
     
-    # Scientific adequacy scores histogram
-    fig.add_trace(
-        go.Histogram(
-            x=df["scientific_adequacy_score"],
-            nbinsx=20,
-            name="Adequacy Scores"
-        ),
-        row=2, col=1
-    )
-    
-    # Model categories distribution
-    category_counts = df["model_category"].value_counts()
-    category_colors = [MODEL_CATEGORIES.get(cat, {}).get("color", "#808080") for cat in category_counts.index]
-    
-    fig.add_trace(
-        go.Bar(
-            x=category_counts.index,
-            y=category_counts.values,
-            marker_color=category_colors,
-            name="Categories"
-        ),
-        row=2, col=2
-    )
-    
+    # Update layout
+    track_info = EVALUATION_TRACKS[track]
     fig.update_layout(
-        title="📊 Scientific Evaluation Analysis",
+        title=f"📊 {track_info['name']} - Language Pair Performance Comparison",
         height=800,
-        showlegend=False
+        barmode='group',
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1
+        )
     )
     
+    # Rotate x-axis labels for better readability
+    fig.update_xaxes(tickangle=45, row=2, col=1)
+    fig.update_yaxes(title_text="Quality Score", row=1, col=1)
+    fig.update_yaxes(title_text="BLEU Score", row=2, col=1)
+    
     return fig
 
 
-def create_cross_track_analysis_plot(df: pd.DataFrame) -> go.Figure:
-    """Create cross-track performance correlation analysis."""
+def create_category_comparison_plot(df: pd.DataFrame, track: str) -> go.Figure:
+    """Create category-wise comparison plot."""
     
     if df.empty:
         fig = go.Figure()
         fig.add_annotation(text="No data available", x=0.5, y=0.5, showarrow=False)
         return fig
     
-    # Get models with data in multiple tracks
-    quality_cols = [f"{track}_quality" for track in EVALUATION_TRACKS.keys()]
-    available_cols = [col for col in quality_cols if col in df.columns]
-    
-    if len(available_cols) < 2:
-        fig = go.Figure()
-        fig.add_annotation(text="Need at least 2 tracks for comparison", x=0.5, y=0.5, showarrow=False)
-        return fig
-    
-    # Filter to models with data in multiple tracks
-    multi_track_models = df.copy()
-    for col in available_cols:
-        multi_track_models = multi_track_models[multi_track_models[col] > 0]
-    
-    if len(multi_track_models) < 3:
-        fig = go.Figure()
-        fig.add_annotation(text="Insufficient models for cross-track analysis", x=0.5, y=0.5, showarrow=False)
-        return fig
+    metric_col = f"{track}_quality"
     
-    # Create scatter plot matrix
-    track_pairs = [(available_cols[i], available_cols[j]) 
-                  for i in range(len(available_cols)) 
-                  for j in range(i+1, len(available_cols))]
+    # Filter to models with data
+    valid_models = df[df[metric_col] > 0]
     
-    if not track_pairs:
+    if valid_models.empty:
         fig = go.Figure()
-        fig.add_annotation(text="No track pairs available", x=0.5, y=0.5, showarrow=False)
+        fig.add_annotation(text="No valid models found", x=0.5, y=0.5, showarrow=False)
         return fig
     
-    # Use first pair for demonstration
-    x_col, y_col = track_pairs[0]
-    x_track = x_col.replace("_quality", "").replace("_", " ").title()
-    y_track = y_col.replace("_quality", "").replace("_", " ").title()
-    
     fig = go.Figure()
     
-    # Color by category
+    # Create box plot for each category
     for category, info in MODEL_CATEGORIES.items():
-        category_models = multi_track_models[multi_track_models["model_category"] == category]
+        category_models = valid_models[valid_models["model_category"] == category]
         
         if len(category_models) > 0:
-            fig.add_trace(go.Scatter(
-                x=category_models[x_col],
-                y=category_models[y_col],
-                mode="markers",
-                marker=dict(
-                    size=10,
-                    color=info["color"],
-                    line=dict(color="black", width=1),
-                ),
+            fig.add_trace(go.Box(
+                y=category_models[metric_col],
                 name=info["name"],
-                text=category_models["model_name"],
+                marker_color=info["color"],
+                boxpoints="all",  # Show all points
+                jitter=0.3,
+                pointpos=-1.8,
                 hovertemplate=(
-                    "<b>%{text}</b><br>" +
-                    f"{x_track}: %{{x:.4f}}<br>" +
-                    f"{y_track}: %{{y:.4f}}<br>" +
-                    f"Category: {info['name']}<br>" +
+                    f"<b>{info['name']}</b><br>" +
+                    "Quality: %{y:.4f}<br>" +
+                    "Model: %{customdata}<br>" +
                     "<extra></extra>"
                 ),
+                customdata=category_models["model_name"],
             ))
     
-    # Add diagonal line for reference
-    min_val = min(multi_track_models[x_col].min(), multi_track_models[y_col].min())
-    max_val = max(multi_track_models[x_col].max(), multi_track_models[y_col].max())
-    
-    fig.add_trace(go.Scatter(
-        x=[min_val, max_val],
-        y=[min_val, max_val],
-        mode="lines",
-        line=dict(dash="dash", color="gray", width=2),
-        name="Perfect Correlation",
-        showlegend=False,
-        hoverinfo="skip",
-    ))
-    
-    fig.update_layout(
-        title=f"🔄 Cross-Track Performance: {x_track} vs {y_track}",
-        xaxis_title=f"{x_track} Quality Score",
-        yaxis_title=f"{y_track} Quality Score",
-        height=600,
-        width=600,
-        plot_bgcolor="white",
-        paper_bgcolor="white",
-    )
-    
-    return fig
-
-
-def create_scientific_model_detail_plot(model_results: Dict, model_name: str, track: str) -> go.Figure:
-    """Create detailed scientific analysis for a specific model."""
-    
-    if not model_results or "tracks" not in model_results:
-        fig = go.Figure()
-        fig.add_annotation(text="No model results available", x=0.5, y=0.5, showarrow=False)
-        return fig
-    
-    track_data = model_results["tracks"].get(track, {})
-    if track_data.get("error") or "pair_metrics" not in track_data:
-        fig = go.Figure()
-        fig.add_annotation(text=f"No data for {track} track", x=0.5, y=0.5, showarrow=False)
-        return fig
-    
-    pair_metrics = track_data["pair_metrics"]
-    track_languages = EVALUATION_TRACKS[track]["languages"]
-    
-    # Extract data for plotting
-    pairs = []
-    quality_means = []
-    quality_cis = []
-    bleu_means = []
-    sample_counts = []
-    
-    for src in track_languages:
-        for tgt in track_languages:
-            if src == tgt:
-                continue
-                
-            pair_key = f"{src}_to_{tgt}"
-            if pair_key in pair_metrics:
-                metrics = pair_metrics[pair_key]
-                
-                if "quality_score" in metrics and "sample_count" in metrics:
-                    pair_label = f"{LANGUAGE_NAMES.get(src, src)} → {LANGUAGE_NAMES.get(tgt, tgt)}"
-                    pairs.append(pair_label)
-                    
-                    quality_stats = metrics["quality_score"]
-                    quality_means.append(quality_stats["mean"])
-                    quality_cis.append([quality_stats["ci_lower"], quality_stats["ci_upper"]])
-                    
-                    bleu_stats = metrics.get("bleu", {"mean": 0})
-                    bleu_means.append(bleu_stats["mean"])
-                    
-                    sample_counts.append(metrics["sample_count"])
-    
-    if not pairs:
-        fig = go.Figure()
-        fig.add_annotation(text="No language pair data available", x=0.5, y=0.5, showarrow=False)
-        return fig
-    
-    # Create subplots
-    fig = make_subplots(
-        rows=2, cols=1,
-        subplot_titles=(
-            "Quality Scores by Language Pair (with 95% CI)",
-            "BLEU Scores by Language Pair"
-        ),
-        vertical_spacing=0.15,
-    )
-    
-    # Quality scores with confidence intervals
-    error_y = dict(
-        type="data",
-        array=[ci[1] - mean for ci, mean in zip(quality_cis, quality_means)],
-        arrayminus=[mean - ci[0] for ci, mean in zip(quality_cis, quality_means)],
-        visible=True,
-        thickness=2,
-        width=4,
-    )
-    
-    fig.add_trace(
-        go.Bar(
-            x=pairs,
-            y=quality_means,
-            error_y=error_y,
-            name="Quality Score",
-            marker_color="steelblue",
-            text=[f"{score:.3f}" for score in quality_means],
-            textposition="outside",
-            hovertemplate=(
-                "<b>%{x}</b><br>" +
-                "Quality: %{y:.4f}<br>" +
-                "Samples: %{customdata}<br>" +
-                "<extra></extra>"
-            ),
-            customdata=sample_counts,
-        ),
-        row=1, col=1
-    )
-    
-    # BLEU scores
-    fig.add_trace(
-        go.Bar(
-            x=pairs,
-            y=bleu_means,
-            name="BLEU Score",
-            marker_color="coral",
-            text=[f"{score:.1f}" for score in bleu_means],
-            textposition="outside",
-        ),
-        row=2, col=1
-    )
-    
     # Customize layout
     track_info = EVALUATION_TRACKS[track]
     fig.update_layout(
-        title=f"🔬 Detailed Analysis: {model_name} - {track_info['name']}",
-        height=900,
+        title=f"📈 {track_info['name']} - Performance by Category",
+        xaxis_title="Model Category",
+        yaxis_title="Quality Score",
+        height=500,
         showlegend=False,
-        margin=dict(l=50, r=50, t=100, b=150),
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
     )
     
-    # Rotate x-axis labels
-    fig.update_xaxes(tickangle=45, row=1, col=1)
-    fig.update_xaxes(tickangle=45, row=2, col=1)
-    
     return fig