Upload from GitHub Actions: model name no bracket stuff

evals/backend.py

@@ -4,7 +4,6 @@ import os
 import numpy as np
 import pandas as pd
 import uvicorn
-
 from countries import make_country_table
 from datasets_.util import load
 from fastapi import FastAPI, Request
@@ -12,8 +11,12 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
+from joblib.memory import Memory
+
+cache = Memory(location=".cache", verbose=0).cache
 
 scores = load("results")
+scores_detailed = load("results-detailed")
 languages = load("languages")
 models = load("models")
 
@@ -31,56 +34,155 @@ task_metrics = [
     "mgsm_accuracy",
 ]
 
+
 def compute_normalized_average(df, metrics):
     """Compute simple average across metric columns without normalization."""
     return df[metrics].mean(axis=1, skipna=False)
 
 
-def make_model_table(scores_df, models):
-    scores_df = scores_df.copy()
-    # Create a combined task_metric for origin
-    scores_df["task_metric_origin"] = (
-        scores_df["task"] + "_" + scores_df["metric"] + "_" + scores_df["origin"]
-    )
+@cache
+def compute_bootstrap_ci(
+    data_hash, group_cols_tuple, n_bootstrap=1000, ci_level=0.95, seed=42
+):
+    """Compute bootstrap CIs for grouped data. Cached based on data hash."""
+    # This function is called with the actual data passed separately via _ci_cache
+    df, group_cols = _ci_cache[data_hash]
+    np.random.seed(seed)
+    percentiles = [(1 - ci_level) / 2 * 100, (1 + ci_level) / 2 * 100]
+
+    def bootstrap_group(group):
+        scores = group["score"].values
+        if len(scores) == 0:
+            return pd.Series({"ci_lower": None, "ci_upper": None})
+        bootstrap_means = [
+            np.random.choice(scores, len(scores), replace=True).mean()
+            for _ in range(n_bootstrap)
+        ]
+        ci_lower, ci_upper = np.percentile(bootstrap_means, percentiles)
+        return pd.Series({"ci_lower": ci_lower, "ci_upper": ci_upper})
 
-    # Pivot to get scores for each origin-specific metric
-    scores_pivot = scores_df.pivot_table(
-        index="model",
-        columns="task_metric_origin",
-        values="score",
-        aggfunc="mean",
+    result = df.groupby(group_cols, as_index=False).apply(
+        bootstrap_group, include_groups=False
     )
+    result.columns = group_cols + ["ci_lower", "ci_upper"]
+    return result
+
+
+# Thread-safe cache for passing DataFrames to cached function
+_ci_cache = {}
+
+
+def add_confidence_intervals(df, scores_df_detailed, group_col, metrics):
+    """DRY helper to add CI columns for metrics and average to a dataframe."""
+    if scores_df_detailed is None or scores_df_detailed.empty:
+        return df
+
+    detailed = scores_df_detailed.copy()
+    detailed["task_metric"] = detailed["task"] + "_" + detailed["metric"]
+
+    # Add CI for each metric
+    for metric in metrics:
+        metric_data = detailed[detailed["task_metric"] == metric]
+        if not metric_data.empty:
+            # Create hash based on data shape, groups, and statistics
+            group_stats = (
+                metric_data.groupby(group_col)["score"]
+                .agg(["count", "mean", "std"])
+                .round(6)
+            )
+            data_hash = hash(
+                (
+                    metric,
+                    group_col,
+                    len(metric_data),
+                    tuple(group_stats.index),
+                    tuple(map(tuple, group_stats.values)),
+                )
+            )
+            _ci_cache[data_hash] = (metric_data, [group_col])
+            ci_df = compute_bootstrap_ci(data_hash, (group_col,))
+            ci_df = ci_df.rename(
+                columns={
+                    "ci_lower": f"{metric}_ci_lower",
+                    "ci_upper": f"{metric}_ci_upper",
+                }
+            )
+            df = pd.merge(df, ci_df, on=group_col, how="left")
+
+    # Add CI for average
+    avg_data = detailed[detailed["task_metric"].isin(metrics)]
+    if not avg_data.empty:
+        # Create hash based on data shape, groups, and statistics
+        group_stats = (
+            avg_data.groupby(group_col)["score"].agg(["count", "mean", "std"]).round(6)
+        )
+        data_hash = hash(
+            (
+                "average",
+                group_col,
+                len(avg_data),
+                tuple(group_stats.index),
+                tuple(map(tuple, group_stats.values)),
+            )
+        )
+        _ci_cache[data_hash] = (avg_data, [group_col])
+        avg_ci_df = compute_bootstrap_ci(data_hash, (group_col,))
+        avg_ci_df = avg_ci_df.rename(
+            columns={"ci_lower": "average_ci_lower", "ci_upper": "average_ci_upper"}
+        )
+        df = pd.merge(df, avg_ci_df, on=group_col, how="left")
+
+    return df
 
-    # Create the regular task_metric for the main average calculation
+
+def make_model_table(scores_df, models, scores_df_detailed=None):
+    scores_df = scores_df.copy()
     scores_df["task_metric"] = scores_df["task"] + "_" + scores_df["metric"]
+    scores_df["task_metric_origin"] = (
+        scores_df["task_metric"] + "_" + scores_df["origin"]
+    )
+
+    # Pivot scores
     main_pivot = scores_df.pivot_table(
         index="model", columns="task_metric", values="score", aggfunc="mean"
     )
-
-    # Merge the two pivots
+    scores_pivot = scores_df.pivot_table(
+        index="model", columns="task_metric_origin", values="score", aggfunc="mean"
+    )
     df = pd.merge(main_pivot, scores_pivot, on="model", how="outer")
 
+    # Fill missing metrics and compute average
     for metric in task_metrics:
-        if metric not in df.columns:
-            df[metric] = np.nan
-
+        df[metric] = df.get(metric, np.nan)
     df["average"] = compute_normalized_average(df, task_metrics)
+    df = add_confidence_intervals(df, scores_df_detailed, "model", task_metrics)
 
-    # Add flag if any machine-origin data was used
-    machine_presence = scores_df[scores_df["origin"] == "machine"].groupby(["model", "task_metric"]).size()
+    # Add machine-origin flags
+    machine_presence = (
+        scores_df[scores_df["origin"] == "machine"]
+        .groupby(["model", "task_metric"])
+        .size()
+    )
     for metric in task_metrics:
-        df[f"{metric}_contains_machine"] = df.index.map(lambda m: (m, metric) in machine_presence.index)
+        df[f"{metric}_contains_machine"] = df.index.map(
+            lambda m: (m, metric) in machine_presence.index
+        )
+
+    # Sort and add metadata
     df = df.sort_values(by="average", ascending=False).reset_index()
     df = pd.merge(df, models, left_on="model", right_on="id", how="left")
     df["rank"] = df.index + 1
+    df["creation_date"] = df["creation_date"].apply(
+        lambda x: x.isoformat() if x else None
+    )
 
-    # Dynamically find all metric columns to include
-    final_cols = df.columns
-    metric_cols = [m for m in final_cols if any(tm in m for tm in task_metrics)]
-
-    df["creation_date"] = df["creation_date"].apply(lambda x: x.isoformat() if x else None)
+    # Select columns dynamically
+    metric_cols = [m for m in df.columns if any(tm in m for tm in task_metrics)]
+    avg_ci_cols = [
+        c for c in df.columns if c in ["average_ci_lower", "average_ci_upper"]
+    ]
 
-    df = df[
+    return df[
         [
             "rank",
             "model",
@@ -93,42 +195,58 @@ def make_model_table(scores_df, models):
             "license",
             "cost",
             "average",
-            *sorted(list(set(metric_cols))),
+            *avg_ci_cols,
+            *sorted(set(metric_cols)),
         ]
     ]
-    return df
 
 
-def make_language_table(scores_df, languages):
+def make_language_table(scores_df, languages, scores_df_detailed=None):
     scores_df = scores_df.copy()
     scores_df["task_metric"] = scores_df["task"] + "_" + scores_df["metric"]
-    
-    # Pivot scores
+
+    # Pivot scores and origins
     score_pivot = scores_df.pivot_table(
         index="bcp_47", columns="task_metric", values="score", aggfunc="mean"
     )
-    
-    # Pivot origins (first origin since each task+lang combo has only one)
     origin_pivot = scores_df.pivot_table(
         index="bcp_47", columns="task_metric", values="origin", aggfunc="first"
     )
     origin_pivot = origin_pivot.add_suffix("_origin")
-    
     df = pd.merge(score_pivot, origin_pivot, on="bcp_47", how="outer")
-    
-    for metric in task_metrics:
-        if metric not in df.columns:
-            df[metric] = np.nan
 
+    # Fill missing metrics and compute average
+    for metric in task_metrics:
+        df[metric] = df.get(metric, np.nan)
     df["average"] = compute_normalized_average(df, task_metrics)
-    df = pd.merge(languages, df, on="bcp_47", how="outer")
-    df = df.sort_values(by="speakers", ascending=False)
 
-    # Dynamically find all metric columns to include
-    final_cols = df.columns
-    metric_cols = [m for m in final_cols if any(tm in m for tm in task_metrics)]
+    # For language table, we need to compute scores from detailed data to match CI calculation
+    # (CI is computed from all samples, so score should be too)
+    if scores_df_detailed is not None and not scores_df_detailed.empty:
+        detailed = scores_df_detailed.copy()
+        detailed["task_metric"] = detailed["task"] + "_" + detailed["metric"]
+        detailed_pivot = detailed.pivot_table(
+            index="bcp_47", columns="task_metric", values="score", aggfunc="mean"
+        )
+        for metric in task_metrics:
+            if metric in detailed_pivot.columns:
+                df[metric] = detailed_pivot[metric]
+        df["average"] = compute_normalized_average(df, task_metrics)
+
+    df = add_confidence_intervals(df, scores_df_detailed, "bcp_47", task_metrics)
+
+    # Merge with language metadata and sort
+    df = pd.merge(languages, df, on="bcp_47", how="outer").sort_values(
+        by="speakers", ascending=False
+    )
+
+    # Select columns dynamically
+    metric_cols = [m for m in df.columns if any(tm in m for tm in task_metrics)]
+    avg_ci_cols = [
+        c for c in df.columns if c in ["average_ci_lower", "average_ci_upper"]
+    ]
 
-    df = df[
+    return df[
         [
             "bcp_47",
             "language_name",
@@ -136,110 +254,97 @@ def make_language_table(scores_df, languages):
             "speakers",
             "family",
             "average",
+            *avg_ci_cols,
             "in_benchmark",
-            *sorted(list(set(metric_cols))),
+            *sorted(set(metric_cols)),
         ]
     ]
-    return df
 
 
 def make_language_tier_history(scores_df, languages, models):
-    # Rank languages by speakers
-    ranked_langs = languages.sort_values(by="speakers", ascending=False).reset_index(drop=True)
-    
-    # Define tiers
-    tier_ranges = {
-        "Top 1": (0, 1),
-        "Top 2-20": (1, 20),
-        "Top 20-200": (19, 500),
-    }
-    
+    ranked_langs = languages.sort_values(by="speakers", ascending=False).reset_index(
+        drop=True
+    )
+    tier_ranges = {"Top 1": (0, 1), "Top 2-20": (1, 20), "Top 20-200": (19, 500)}
+
     # Calculate model-language proficiency scores
     scores_df = scores_df.copy()
     scores_df["task_metric"] = scores_df["task"] + "_" + scores_df["metric"]
-    
-    # Pivot to get model-language-metric scores
     pivot = scores_df.pivot_table(
-        index=["model", "bcp_47"],
-        columns="task_metric",
-        values="score",
-        aggfunc="mean"
+        index=["model", "bcp_47"], columns="task_metric", values="score", aggfunc="mean"
     )
-    
-    # Ensure all task_metrics columns exist
     for metric in task_metrics:
-        if metric not in pivot.columns:
-            pivot[metric] = np.nan
-    
-    # Calculate proficiency score for each model-language pair
+        pivot[metric] = pivot.get(metric, np.nan)
     pivot["proficiency_score"] = compute_normalized_average(pivot, task_metrics)
     pivot = pivot.reset_index()
-    
-    # Create all tier-level aggregations (allowing overlapping tiers)
-    all_tier_scores = []
-    for tier_name, (start, end) in tier_ranges.items():
-        tier_langs = ranked_langs.iloc[start:end]["bcp_47"].tolist()
-        tier_data = pivot[pivot["bcp_47"].isin(tier_langs)]
-        tier_scores = tier_data.groupby("model")["proficiency_score"].mean().reset_index()
-        tier_scores["tier"] = tier_name
-        all_tier_scores.append(tier_scores)
-    
-    tier_scores = pd.concat(all_tier_scores, ignore_index=True)
-    
-    # Merge with models data
-    tier_scores = pd.merge(tier_scores, models, left_on="model", right_on="id", how="left")
-    
-    # Select relevant columns
-    tier_scores = tier_scores[
-        ["model", "name", "provider_name", "creation_date", "size", "tier", "proficiency_score"]
-    ]
-    
+
+    # Aggregate by tier
+    tier_scores = pd.concat(
+        [
+            pivot[pivot["bcp_47"].isin(ranked_langs.iloc[start:end]["bcp_47"])]
+            .groupby("model")["proficiency_score"]
+            .mean()
+            .reset_index()
+            .assign(tier=tier_name)
+            for tier_name, (start, end) in tier_ranges.items()
+        ],
+        ignore_index=True,
+    )
+
+    tier_scores = pd.merge(
+        tier_scores, models, left_on="model", right_on="id", how="left"
+    )
     tier_scores["creation_date"] = tier_scores["creation_date"].apply(
         lambda x: x.isoformat() if x else None
     )
-    
-    return tier_scores
+
+    return tier_scores[
+        [
+            "model",
+            "name",
+            "provider_name",
+            "creation_date",
+            "size",
+            "tier",
+            "proficiency_score",
+        ]
+    ]
 
 
 def make_license_history(scores_df, models):
     scores_df = scores_df.copy()
     scores_df["task_metric"] = scores_df["task"] + "_" + scores_df["metric"]
-    
-    # Pivot to get model-level scores
+
+    # Pivot and compute proficiency
     pivot = scores_df.pivot_table(
-        index="model",
-        columns="task_metric",
-        values="score",
-        aggfunc="mean"
+        index="model", columns="task_metric", values="score", aggfunc="mean"
     )
-    
-    # Ensure all task_metrics columns exist
     for metric in task_metrics:
-        if metric not in pivot.columns:
-            pivot[metric] = np.nan
-    
-    # Calculate proficiency score for each model
+        pivot[metric] = pivot.get(metric, np.nan)
     pivot["proficiency_score"] = compute_normalized_average(pivot, task_metrics)
-    pivot = pivot.reset_index()
-    
-    # Merge with models data
-    df = pd.merge(pivot, models, left_on="model", right_on="id", how="left")
-    
-    # Classify as commercial or open
+
+    # Merge and classify
+    df = pd.merge(
+        pivot.reset_index(), models, left_on="model", right_on="id", how="left"
+    )
     df["license_type"] = df["type"].apply(
         lambda x: "Open-source" if x == "open-source" else "Commercial"
     )
-    
-    # Select relevant columns
-    df = df[
-        ["model", "name", "provider_name", "creation_date", "size", "license_type", "proficiency_score"]
-    ]
-    
     df["creation_date"] = df["creation_date"].apply(
         lambda x: x.isoformat() if x else None
     )
-    
-    return df
+
+    return df[
+        [
+            "model",
+            "name",
+            "provider_name",
+            "creation_date",
+            "size",
+            "license_type",
+            "proficiency_score",
+        ]
+    ]
 
 
 app = FastAPI()
@@ -257,38 +362,53 @@ async def data(request: Request):
     body = await request.body()
     data = json.loads(body)
     selected_languages = data.get("selectedLanguages", {})
-    
+
     # Identify which metrics have machine translations available
     machine_translated_metrics = {
-        f"{row['task']}_{row['metric']}" 
-        for _, row in scores.iterrows() 
+        f"{row['task']}_{row['metric']}"
+        for _, row in scores.iterrows()
         if row["origin"] == "machine"
     }
 
     # Filter by selected languages if provided
-    df = scores[scores["bcp_47"].isin(lang["bcp_47"] for lang in selected_languages)] if selected_languages else scores
-    
+    df = (
+        scores[scores["bcp_47"].isin(lang["bcp_47"] for lang in selected_languages)]
+        if selected_languages
+        else scores
+    )
+    df_detailed = (
+        scores_detailed[
+            scores_detailed["bcp_47"].isin(
+                lang["bcp_47"] for lang in selected_languages
+            )
+        ]
+        if selected_languages
+        else scores_detailed
+    )
+
     if len(df) == 0:
         model_table = pd.DataFrame()
         countries = pd.DataFrame()
     else:
-        model_table = make_model_table(df, models)
-        countries = make_country_table(make_language_table(df, languages))
-    
-    language_table = make_language_table(scores, languages)
+        model_table = make_model_table(df, models, df_detailed)
+        countries = make_country_table(make_language_table(df, languages, df_detailed))
+
+    language_table = make_language_table(scores, languages, scores_detailed)
     language_tier_history = make_language_tier_history(scores, languages, models)
     license_history = make_license_history(scores, models)
     datasets_df = pd.read_json("data/datasets.json")
-    
-    return JSONResponse(content={
-        "model_table": serialize(model_table),
-        "language_table": serialize(language_table),
-        "dataset_table": serialize(datasets_df),
-        "countries": serialize(countries),
-        "machine_translated_metrics": list(machine_translated_metrics),
-        "language_tier_history": serialize(language_tier_history),
-        "license_history": serialize(license_history),
-    })
+
+    return JSONResponse(
+        content={
+            "model_table": serialize(model_table),
+            "language_table": serialize(language_table),
+            "dataset_table": serialize(datasets_df),
+            "countries": serialize(countries),
+            "machine_translated_metrics": list(machine_translated_metrics),
+            "language_tier_history": serialize(language_tier_history),
+            "license_history": serialize(license_history),
+        }
+    )
 
 
 # Only serve static files if build directory exists

evals/models.py

@@ -364,7 +364,8 @@ def load_models(date: date) -> pd.DataFrame:
     models = models.assign(
         name=or_metadata.str["short_name"]
         .str.replace(" (free)", "")
-        .str.replace(" (self-moderated)", ""),
+        .str.replace(" (self-moderated)", "")
+        .str.replace(r"\s*\([^)]*\)\s*$", "", regex=True),
         provider_name=or_metadata.str["name"].str.split(": ").str[0],
         # openrouter_metadata=or_metadata.astype(str),
         cost=or_metadata.apply(get_cost),

frontend/src/App.js

@@ -20,6 +20,7 @@ function App () {
   const [data, setData] = useState(null)
   const [baseData, setBaseData] = useState(null)
   const [loading, setLoading] = useState(true)
+  const [modelTableLoading, setModelTableLoading] = useState(false)
   const [error, setError] = useState(null)
   const [selectedLanguages, setSelectedLanguages] = useState([])
   const [machineTranslatedMetrics, setMachineTranslatedMetrics] = useState([])
@@ -32,6 +33,13 @@ function App () {
   const [fullScreenCarouselItems, setFullScreenCarouselItems] = useState([])
 
   useEffect(() => {
+    // For initial load, use main loading state; for language changes, use model table loading
+    if (!data) {
+      setLoading(true)
+    } else {
+      setModelTableLoading(true)
+    }
+    
     fetch('/api/data', {
       method: 'POST',
       body: JSON.stringify({ selectedLanguages })
@@ -47,10 +55,12 @@ function App () {
         setMachineTranslatedMetrics(jsonData.machine_translated_metrics || [])
         if (!baseData) setBaseData(jsonData)
         setLoading(false)
+        setModelTableLoading(false)
       })
       .catch(err => {
         setError(err.message)
         setLoading(false)
+        setModelTableLoading(false)
       })
   }, [selectedLanguages])
 
@@ -146,7 +156,7 @@ function App () {
           width: '100vw'
         }}
       >
-        <div
+        {/* <div
           style={{
             backgroundColor: '#fff3cd',
             color: '#856404',
@@ -161,7 +171,7 @@ function App () {
         >
           <strong>Work in Progress:</strong> This dashboard is currently under
           active development. Evaluation results are not yet final. More extensive evaluation runs will be released later this year.
-        </div>
+        </div> */}
         <div
           style={{
             display: 'flex',
@@ -361,12 +371,30 @@ function App () {
           )}
           {data && (
             <>
-              <ModelTable
-                data={data.model_table}
-                selectedLanguages={selectedLanguages}
-                allLanguages={data.language_table || []}
-                machineTranslatedMetrics={machineTranslatedMetrics}
-              />
+              <div style={{ position: 'relative' }}>
+                {modelTableLoading && (
+                  <div style={{
+                    position: 'absolute',
+                    top: 0,
+                    left: 0,
+                    right: 0,
+                    bottom: 0,
+                    backgroundColor: 'rgba(255, 255, 255, 0.8)',
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    zIndex: 1000
+                  }}>
+                    <i className='pi pi-spinner pi-spin' style={{ fontSize: '3rem' }} />
+                  </div>
+                )}
+                <ModelTable
+                  data={data.model_table}
+                  selectedLanguages={selectedLanguages}
+                  allLanguages={data.language_table || []}
+                  machineTranslatedMetrics={machineTranslatedMetrics}
+                />
+              </div>
               <LanguageTable
                 data={data.language_table}
                 selectedLanguages={selectedLanguages}

frontend/src/components/DatasetTable.js

@@ -98,6 +98,7 @@ const DatasetTable = ({ data }) => {
   return (
     <DataTable
       value={table}
+      dataKey='name'
       rowGroupMode='subheader'
       rowGroupHeaderTemplate={rowData => {
         return <div style={{ fontWeight: 'bold' }}>{rowData.group}</div>

frontend/src/components/LanguageTable.js

@@ -122,6 +122,7 @@ const LanguageTable = ({ data, selectedLanguages, setSelectedLanguages, totalMod
       value={data.filter(
         item => !selectedLanguages.some(l => l.bcp_47 === item.bcp_47)
       )}
+      dataKey='bcp_47'
       header={
         <span>
           <span style={{ fontWeight: 'bold', fontSize: '1.1em' }}>Languages</span>

frontend/src/components/ModelTable.js

@@ -225,6 +225,7 @@ const ModelTable = ({ data, selectedLanguages = [], allLanguages = [], machineTr
   return (
     <DataTable
       value={data}
+      dataKey='name'
       header={<>{getHeaderText()}</>}
       sortField='average'
       removableSort

frontend/src/components/ScoreColumns.js

@@ -2,112 +2,117 @@ import { Column } from 'primereact/column'
 import ScoreField from './ScoreField'
 
 const scoreBodyTemplate = (field, options = {}) => {
-  const { minScore = 0, maxScore = 1, machineTranslatedMetrics = [] } = options
+  const {
+    minScore = 0,
+    maxScore = 1,
+    machineTranslatedMetrics = [],
+    ciLowerField = null,
+    ciUpperField = null
+  } = options
 
   return rowData => {
     const score = rowData[field]
-    // Prefer per-row flag if present (backend sets `<metric>_is_machine`),
-    // otherwise fall back to global list
     const rowFlagKey = `${field}_is_machine`
     const hasRowFlag = Object.prototype.hasOwnProperty.call(rowData, rowFlagKey)
     const isMachineTranslated = hasRowFlag
       ? !!rowData[rowFlagKey]
       : machineTranslatedMetrics.includes(field)
-    return ScoreField(score, minScore, maxScore, isMachineTranslated)
+    const ciLower = ciLowerField ? rowData[ciLowerField] : null
+    const ciUpper = ciUpperField ? rowData[ciUpperField] : null
+    return (
+      <ScoreField
+        score={score}
+        minScore={minScore}
+        maxScore={maxScore}
+        isMachineTranslated={isMachineTranslated}
+        ciLower={ciLower}
+        ciUpper={ciUpper}
+      />
+    )
   }
 }
 
-const ScoreColumns = (machineTranslatedMetrics = []) => [
-  <Column
-    field='average'
-    header='Proficiency'
-    headerTooltip='Language Proficiency Score (average of the scores for each task)'
-    sortable
-    body={scoreBodyTemplate('average', { minScore: 0.3, maxScore: 0.7, machineTranslatedMetrics })}
-    style={{ minWidth: '5rem', maxWidth: '10rem' }}
-  />,
-  <Column
-    field='translation_from_bleu'
-    header='Translation (from)'
-    headerTooltip='Translation performance from a language to all other languages (spBLEU score on a sample of the FLORES+ benchmark)'
-    sortable
-    body={scoreBodyTemplate('translation_from_bleu', {
-      minScore: 0,
-      maxScore: 0.4,
-      machineTranslatedMetrics
-    })}
-    style={{ minWidth: '5rem', maxWidth: '10rem' }}
-  />,
-  <Column
-    field='translation_to_bleu'
-    header='Translation (to)'
-    headerTooltip='Translation performance from all other languages to a language (spBLEU score on a sample of the FLORES+ benchmark)'
-    sortable
-    body={scoreBodyTemplate('translation_to_bleu', {
-      minScore: 0,
-      maxScore: 0.4,
-      machineTranslatedMetrics
-    })}
-    style={{ minWidth: '5rem', maxWidth: '10rem' }}
-  />,
-  <Column
-    field='classification_accuracy'
-    header='Classification'
-    headerTooltip='Classification performance (accuracy on a sample of the SIB-200 / FLORES+ classification benchmark)'
-    sortable
-    body={scoreBodyTemplate('classification_accuracy', {
-      minScore: 0.4,
-      maxScore: 1,
-      machineTranslatedMetrics
-    })}
-    style={{ minWidth: '5rem', maxWidth: '10rem' }}
-  />,
-  //   <Column
-  //     field='language_modeling_chrf'
-  //     header='Language Modeling'
-  //     sortable
-  //     body={scoreBodyTemplate('language_modeling_chrf', {
-  //       minScore: 0.8,
-  //       maxScore: 1
-  //     })}
-  //     style={{ minWidth: '5rem', maxWidth: '10rem' }}
-  //   />,
-  <Column
-    field='mmlu_accuracy'
-    header='Q&A'
-    headerTooltip='Question Answering performance (accuracy on a sample of multilingual versions of the MMLU benchmark)'
-    sortable
-    body={scoreBodyTemplate('mmlu_accuracy', {
-      minScore: 0,
-      maxScore: 1,
-      machineTranslatedMetrics
-    })}
-    style={{ minWidth: '5rem', maxWidth: '10rem' }}
-  />,
+const createScoreColumn = (
+  field,
+  header,
+  tooltip,
+  minScore,
+  maxScore,
+  machineTranslatedMetrics
+) => (
   <Column
-    field='arc_accuracy'
-    header='Advanced Q&A'
-    headerTooltip='Advanced Question Answering performance (accuracy on a sample of multilingual versions of the ARC-Easy benchmark)'
+    field={field}
+    header={header}
+    headerTooltip={tooltip}
     sortable
-    body={scoreBodyTemplate('arc_accuracy', {
-      minScore: 0,
-      maxScore: 1,
-      machineTranslatedMetrics
+    body={scoreBodyTemplate(field, {
+      minScore,
+      maxScore,
+      machineTranslatedMetrics,
+      ciLowerField: `${field}_ci_lower`,
+      ciUpperField: `${field}_ci_upper`
     })}
     style={{ minWidth: '5rem', maxWidth: '10rem' }}
-  />,
-  <Column
-    field='mgsm_accuracy'
-    header='Math'
-    headerTooltip='Math Problem Solving performance (accuracy on a sample of multilingual versions of the GSM8K benchmark)'
-    sortable
-    body={scoreBodyTemplate('mgsm_accuracy', {
-      minScore: 0,
-      maxScore: 1,
-      machineTranslatedMetrics
-    })}
-    style={{ minWidth: '5rem', maxWidth: '10rem' }}
-  />,
+  />
+)
+
+const ScoreColumns = (machineTranslatedMetrics = []) => [
+  createScoreColumn(
+    'average',
+    'Proficiency',
+    'Language Proficiency Score (average of the scores for each task)',
+    0,
+    1,
+    machineTranslatedMetrics
+  ),
+  createScoreColumn(
+    'translation_from_bleu',
+    'Translation (from)',
+    'Translation performance from a language to all other languages (spBLEU score on a sample of the FLORES+ benchmark)',
+    0,
+    1,
+    machineTranslatedMetrics
+  ),
+  createScoreColumn(
+    'translation_to_bleu',
+    'Translation (to)',
+    'Translation performance from all other languages to a language (spBLEU score on a sample of the FLORES+ benchmark)',
+    0,
+    1,
+    machineTranslatedMetrics
+  ),
+  createScoreColumn(
+    'classification_accuracy',
+    'Classification',
+    'Classification performance (accuracy on a sample of the SIB-200 / FLORES+ classification benchmark)',
+    0,
+    1,
+    machineTranslatedMetrics
+  ),
+  createScoreColumn(
+    'mmlu_accuracy',
+    'Q&A',
+    'Question Answering performance (accuracy on a sample of multilingual versions of the MMLU benchmark)',
+    0,
+    1,
+    machineTranslatedMetrics
+  ),
+  createScoreColumn(
+    'arc_accuracy',
+    'Advanced Q&A',
+    'Advanced Question Answering performance (accuracy on a sample of multilingual versions of the ARC-Easy benchmark)',
+    0,
+    1,
+    machineTranslatedMetrics
+  ),
+  createScoreColumn(
+    'mgsm_accuracy',
+    'Math',
+    'Math Problem Solving performance (accuracy on a sample of multilingual versions of the GSM8K benchmark)',
+    0,
+    1,
+    machineTranslatedMetrics
+  )
 ]
 
 export default ScoreColumns

frontend/src/components/ScoreField.js

@@ -1,24 +1,34 @@
-const ScoreField = (score, minScore, maxScore, isMachineTranslated = false) => {
+const ScoreField = ({ score, minScore, maxScore, isMachineTranslated = false, ciLower = null, ciUpper = null }) => {
   let percentage = 100
   let barColor = "rgba(210, 106, 255, 0.1)" // light violet for missing data
+  let ciLowerPercentage = null
+  let ciUpperPercentage = null
+  
   if (score !== null) {
-  // Calculate percentage based on the provided min and max scores
-  // This normalizes the score to a 0-100 range for visualization
-  const normalizedScore = Math.min(Math.max(score, minScore), maxScore)
-  percentage =
-    ((normalizedScore - minScore) / (maxScore - minScore)) * 100
+    // Calculate percentage based on the provided min and max scores
+    // This normalizes the score to a 0-100 range for visualization
+    const normalizedScore = Math.min(Math.max(score, minScore), maxScore)
+    percentage = ((normalizedScore - minScore) / (maxScore - minScore)) * 100
 
-  // Continuous color gradient from red to green based on score
-  // For a smooth transition, calculate the RGB values directly
+    // Continuous color gradient from red to green based on score
+    // For a smooth transition, calculate the RGB values directly
 
-  // Red component decreases as score increases
-  const red = Math.round(255 * (1 - percentage / 100))
-  // Green component increases as score increases
-  const green = Math.round(255 * (percentage / 100))
-  // Use a low opacity for subtlety (0.1-0.2 range)
-  const opacity = 0.1 + (percentage / 100) * 0.1
+    // Red component decreases as score increases
+    const red = Math.round(255 * (1 - percentage / 100))
+    // Green component increases as score increases
+    const green = Math.round(255 * (percentage / 100))
+    // Use a low opacity for subtlety (0.1-0.2 range)
+    const opacity = 0.1 + (percentage / 100) * 0.1
 
-  barColor = `rgba(${red}, ${green}, 0, ${opacity.toFixed(2)})`
+    barColor = `rgba(${red}, ${green}, 0, ${opacity.toFixed(2)})`
+    
+    // Calculate CI percentages if available
+    if (ciLower !== null && ciUpper !== null) {
+      const normalizedCiLower = Math.min(Math.max(ciLower, minScore), maxScore)
+      const normalizedCiUpper = Math.min(Math.max(ciUpper, minScore), maxScore)
+      ciLowerPercentage = ((normalizedCiLower - minScore) / (maxScore - minScore)) * 100
+      ciUpperPercentage = ((normalizedCiUpper - minScore) / (maxScore - minScore)) * 100
+    }
   }
 
   return (
@@ -39,14 +49,56 @@ const ScoreField = (score, minScore, maxScore, isMachineTranslated = false) => {
           width: `${percentage}%`,
           backgroundColor: barColor,
           zIndex: 0,
-          transition: 'width 0.3s, background-color 0.3s'
+          // transition: 'width 0.3s, background-color 0.3s'
         }}
       />
+      
+      {/* Confidence interval error bar */}
+      {ciLowerPercentage !== null && ciUpperPercentage !== null && (
+        <div
+          style={{
+            position: 'absolute',
+            top: '50%',
+            left: `${ciLowerPercentage}%`,
+            width: `${ciUpperPercentage - ciLowerPercentage}%`,
+            height: '2px',
+            backgroundColor: 'rgba(0, 0, 0, 0.3)',
+            zIndex: 1,
+            transform: 'translateY(-50%)',
+            // transition: 'left 0.3s, width 0.3s'
+          }}
+        >
+          {/* Left cap */}
+          <div
+            style={{
+              position: 'absolute',
+              left: 0,
+              top: '50%',
+              width: '1px',
+              height: '8px',
+              backgroundColor: 'rgba(0, 0, 0, 0.3)',
+              transform: 'translate(-50%, -50%)'
+            }}
+          />
+          {/* Right cap */}
+          <div
+            style={{
+              position: 'absolute',
+              right: 0,
+              top: '50%',
+              width: '1px',
+              height: '8px',
+              backgroundColor: 'rgba(0, 0, 0, 0.3)',
+              transform: 'translate(50%, -50%)'
+            }}
+          />
+        </div>
+      )}
 
       <span
         style={{
           position: 'relative',
-          zIndex: 1
+          zIndex: 2
         }}
       >
         {score !== null ? (score * 100).toFixed(1)+"%" : '–'}