improve distinction between Spanish and Spanish Mixed

app.py

@@ -8,6 +8,7 @@ from pathlib import Path
 import pandas as pd
 import streamlit as st
 import plotly.express as px
+import plotly.graph_objects as go
 
 from datasets import load_dataset
 from huggingface_hub import CommitScheduler, hf_hub_download
@@ -20,7 +21,12 @@ from src.task_mappings import professional_mapping, semantic_categories
 # -----------------------------------------------------------------------------
 # Page configuration and global CSS styles for modern look and improved UX
 # -----------------------------------------------------------------------------
-st.set_page_config(page_title="IberBench", layout="wide", initial_sidebar_state="expanded", page_icon="🌍")
+st.set_page_config(
+    page_title="IberBench",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    page_icon="🌍",
+)
 
 st.markdown(
     """
@@ -68,8 +74,16 @@ request_folder = request_file.parent
 LANGUAGES_SETTINGS = Path("etc/languages_settings.yml")
 
 dataset_columns = [
-    "workshop", "shared_task", "year", "task_type", "language", 
-    "url", "language_variety", "problem_type", "num_labels", "labels",
+    "workshop",
+    "shared_task",
+    "year",
+    "task_type",
+    "language",
+    "url",
+    "language_variety",
+    "problem_type",
+    "num_labels",
+    "labels",
 ]
 model_columns = ["model_name", "model_type", "num_parameters"]
 
@@ -83,30 +97,42 @@ scheduler = CommitScheduler(
     every=10,
 )
 
+
 def log_submission(input_dict: dict) -> None:
     with scheduler.lock:
         with request_file.open("a") as f:
             f.write(json.dumps(input_dict))
             f.write("\n")
 
+
 def get_lang_columns(columns: list, lang: str):
-    lang_norm = lang.lower().replace(" ", "_")
-    return [col for col in columns if lang_norm in col]
+    # Mixed needs to return all the columns that ends
+    # with the language, but doesn't have variation at the end
+    if "Mixed" in lang:
+        lang = lang.lower().split(" ")[0]
+        return [col for col in columns if col.endswith(lang)]
+    else:
+        lang_norm = lang.lower().replace(" ", "_")
+        return [col for col in columns if lang_norm in col]
+
 
 @st.cache_data
 def load_data(lang) -> pd.DataFrame:
     try:
-        data = load_dataset("iberbench/lm-eval-results", token=st.secrets["HF_TOKEN"])["train"].to_pandas()
+        data = load_dataset(
+            "iberbench/lm-eval-results", token=st.secrets["HF_TOKEN"]
+        )["train"].to_pandas()
         task_columns = [col for col in data.columns if col not in model_columns]
         task_lang_columns = get_lang_columns(task_columns, lang)
-        data[task_columns] = data[task_columns]*100
+        data[task_columns] = data[task_columns] * 100
         data = data[model_columns + task_lang_columns]
-        #data["Active"] = False
+        # data["Active"] = False
         return data
     except FileNotFoundError:
         st.error("iberbench/lm-eval-results was not found in the hub 😕")
         return pd.DataFrame()
 
+
 def load_dataset_card(task) -> list:
     name_repo = "iberbench/" + task
     try:
@@ -130,16 +156,24 @@ def load_dataset_card(task) -> list:
 
 
 def active_data(lang) -> pd.DataFrame:
-    return st.session_state[f"leaderboard_data_{lang}"][st.session_state[f"leaderboard_data_{lang}"]["Active"] == True].copy()
+    return st.session_state[f"leaderboard_data_{lang}"][
+        st.session_state[f"leaderboard_data_{lang}"]["Active"] == True
+    ].copy()
+
 
 def get_index(lang, row) -> pd.Series:
     return active_data(lang).iloc[row].name
 
+
 def commit(lang) -> None:
     for row in st.session_state[f"edited_data_{lang}"]["edited_rows"]:
         row_index = get_index(lang, row)
-        for key, value in st.session_state[f"edited_data_{lang}"]["edited_rows"][row].items():
-            st.session_state[f"leaderboard_data_{lang}"].at[row_index, key] = value
+        for key, value in st.session_state[f"edited_data_{lang}"][
+            "edited_rows"
+        ][row].items():
+            st.session_state[f"leaderboard_data_{lang}"].at[
+                row_index, key
+            ] = value
 
 
 # -----------------------------------------------------------------------------
@@ -172,10 +206,14 @@ def create_table_results(df_mean: pd.DataFrame):
 
 def create_table_all_results(aggregated_df: pd.DataFrame):
     combined_df = create_data_results_per_language()
-    df_lang= combined_df.pivot(index='model_name', columns='language', values='Mean') 
-    aggregated_df[df_lang.columns]=df_lang[df_lang.columns].values
+    df_lang = combined_df.pivot(
+        index="model_name", columns="language", values="Mean"
+    )
+    aggregated_df[df_lang.columns] = df_lang[df_lang.columns].values
     rank_value = []
-    for i in aggregated_df["Mean"].rank(method="dense", ascending=False).astype(int):
+    for i in (
+        aggregated_df["Mean"].rank(method="dense", ascending=False).astype(int)
+    ):
         if i == 1:
             rank_value.append(f"{i} 🥇")
         elif i == 2:
@@ -195,7 +233,7 @@ def create_table_all_results(aggregated_df: pd.DataFrame):
             "model_type": st.column_config.TextColumn("Type 📌"),
             "num_parameters": st.column_config.NumberColumn("Model Size 🔢"),
         },
-    ) 
+    )
 
 
 def create_scatter_chart(df: pd.DataFrame, id_: str):
@@ -206,40 +244,57 @@ def create_scatter_chart(df: pd.DataFrame, id_: str):
         color="model_name",
         size="num_parameters",
         hover_data=["model_type"],
-        labels={"num_parameters": "Num parameters"}
+        labels={"num_parameters": "Num parameters"},
     )
     fig.update_layout(template="plotly_white")
-    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
+    st.plotly_chart(
+        fig, use_container_width=True, key=id_ + str(random.random())
+    )
+
 
 def create_radar_chart(df: pd.DataFrame, id_: str):
     df = df.sort_values(by="Mean", ascending=False)
-    radar_df = pd.DataFrame({
-        "r": df["Mean"][:10],
-        "theta": df["model_name"][:10]
-    })
+    radar_df = pd.DataFrame(
+        {"r": df["Mean"][:10], "theta": df["model_name"][:10]}
+    )
     fig = px.line_polar(
-        radar_df, r="r", theta="theta", line_close=True, markers=True,
+        radar_df,
+        r="r",
+        theta="theta",
+        line_close=True,
+        markers=True,
     )
     fig.update_traces(fill="toself")
-    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
+    st.plotly_chart(
+        fig, use_container_width=True, key=id_ + str(random.random())
+    )
 
 
 def create_pie_chart(df: pd.DataFrame, id_: str):
     df_pie = df["model_type"].value_counts().reset_index()
     df_pie.columns = ["model_type", "count"]
     fig = px.pie(
-        df_pie, values="count", names="model_type",
-        labels={"model_type": "Model type"}
+        df_pie,
+        values="count",
+        names="model_type",
+        labels={"model_type": "Model type"},
+    )
+    st.plotly_chart(
+        fig, use_container_width=True, key=id_ + str(random.random())
     )
-    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
 
 
 def create_box_plot(df: pd.DataFrame, id_: str):
     fig = px.box(
-        df, x="model_type", y="Mean", points="all",
-        labels={"model_type": "Model type"}
+        df,
+        x="model_type",
+        y="Mean",
+        points="all",
+        labels={"model_type": "Model type"},
+    )
+    st.plotly_chart(
+        fig, use_container_width=True, key=id_ + str(random.random())
     )
-    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
 
 
 def get_summary_df(lang: str, task_types: list) -> pd.DataFrame:
@@ -247,8 +302,11 @@ def get_summary_df(lang: str, task_types: list) -> pd.DataFrame:
     if not st.session_state[f"leaderboard_data_{lang}"].empty:
         for t in task_types:
             task_list = semantic_categories[t]
-            cols = [col for col in st.session_state[f"leaderboard_data_{lang}"].columns 
-                    if "iberbench/" + col in task_list]
+            cols = [
+                col
+                for col in st.session_state[f"leaderboard_data_{lang}"].columns
+                if "iberbench/" + col in task_list
+            ]
             if cols:
                 tmp = st.session_state[f"leaderboard_data_{lang}"][cols]
                 df[t] = tmp.mean(axis=1).round(2)
@@ -259,7 +317,6 @@ def get_summary_df(lang: str, task_types: list) -> pd.DataFrame:
     return df
 
 
-
 def get_all_languages_summary_df() -> pd.DataFrame:
     """Combine leaderboard summary data from all languages using get_summary_df."""
     combined_df = pd.DataFrame()
@@ -269,7 +326,9 @@ def get_all_languages_summary_df() -> pd.DataFrame:
             task_types = select_task_per_language(lang)
             summary_df = get_summary_df(lang, task_types)
             summary_df["language"] = lang
-            combined_df = pd.concat([combined_df, summary_df], ignore_index=True)
+            combined_df = pd.concat(
+                [combined_df, summary_df], ignore_index=True
+            )
     return combined_df
 
 
@@ -283,14 +342,16 @@ def create_results_visualization_lang(lang: str):
     create_table_results(summary_df)
     st.markdown("### Language plots 📊")
     # Display the results table for the selected language
-    
-    in_lang_tabs = st.tabs([
-        "Top 10 performance 🥇",
-        "Performance vs. size 📏",
-        "Performance per type 💡",
-        "Fundamental vs industry ⚖️",
-        "Performance per task category 📈",
-    ])
+
+    in_lang_tabs = st.tabs(
+        [
+            "Top 10 performance 🥇",
+            "Performance vs. size 📏",
+            "Performance per type 💡",
+            "Fundamental vs industry ⚖️",
+            "Performance per task category 📈",
+        ]
+    )
     with in_lang_tabs[0]:
         create_radar_chart(summary_df, lang + "in_radar")
     with in_lang_tabs[1]:
@@ -301,29 +362,38 @@ def create_results_visualization_lang(lang: str):
         create_box_plot_per_task_category(tasks_df, lang + "in_box_task_cat")
     with in_lang_tabs[4]:
         create_box_plot_per_semantic_category(tasks_df, lang + "in_box_sem_cat")
-    
+
+
 # -----------------------------------------------------------------------------
 # Functions for other visualization sections
 # -----------------------------------------------------------------------------
 
+
 def select_task_per_language(lang: str):
     types = []
     for k, v in semantic_categories.items():
         for vv in v:
             task_name = vv.split("iberbench/")[1]
-            if task_name in list(st.session_state[f"leaderboard_data_{lang}"].columns):
+            if task_name in list(
+                st.session_state[f"leaderboard_data_{lang}"].columns
+            ):
                 if k not in types:
                     types.append(k)
     return types
 
+
 def create_dataset_info_per_language(lang: str):
     all_values = []
     if not st.session_state[f"leaderboard_data_{lang}"].empty:
-        cols = [col for col in st.session_state[f"leaderboard_data_{lang}"].columns if col not in model_columns]
+        cols = [
+            col
+            for col in st.session_state[f"leaderboard_data_{lang}"].columns
+            if col not in model_columns
+        ]
         if len(cols) > 1:
-           for task in cols[:-1]:
-               values = load_dataset_card(task)
-               all_values.append(values)
+            for task in cols[:-1]:
+                values = load_dataset_card(task)
+                all_values.append(values)
         else:
             values = load_dataset_card(cols[0])
             all_values.append(values)
@@ -331,27 +401,50 @@ def create_dataset_info_per_language(lang: str):
         st.dataframe(
             df,
             column_config={
-                "workshop": st.column_config.TextColumn("Workshop 🏫", help="Workshop to belong to the shared task"),
-                "shared_task": st.column_config.TextColumn("Shared Task 📋", help="Shared Task name"),
-                "year": st.column_config.TextColumn("Year 📅", help="Year of the shared task"),
-                "task_type": st.column_config.TextColumn("Task Type 🔖", help="Shared Task type"),
-                "language": st.column_config.TextColumn("Language 🌐", help="Shared Task language"),
-                "url": st.column_config.ListColumn("Task URL 🔗", help="Shared Task url"),
-                "language_variety": st.column_config.TextColumn("Language Variety 🗣️", help="Shared Task language variety"),
-                "problem_type": st.column_config.TextColumn("Problem Type ❓", help="Shared Task problem type"),
-                "num_labels": st.column_config.NumberColumn("Number of Labels 🔢", help="Shared Task number of labels"),
-                "labels": st.column_config.ListColumn("Labels 🏷️", help="Shared Task labels"),
+                "workshop": st.column_config.TextColumn(
+                    "Workshop 🏫", help="Workshop to belong to the shared task"
+                ),
+                "shared_task": st.column_config.TextColumn(
+                    "Shared Task 📋", help="Shared Task name"
+                ),
+                "year": st.column_config.TextColumn(
+                    "Year 📅", help="Year of the shared task"
+                ),
+                "task_type": st.column_config.TextColumn(
+                    "Task Type 🔖", help="Shared Task type"
+                ),
+                "language": st.column_config.TextColumn(
+                    "Language 🌐", help="Shared Task language"
+                ),
+                "url": st.column_config.ListColumn(
+                    "Task URL 🔗", help="Shared Task url"
+                ),
+                "language_variety": st.column_config.TextColumn(
+                    "Language Variety 🗣️", help="Shared Task language variety"
+                ),
+                "problem_type": st.column_config.TextColumn(
+                    "Problem Type ❓", help="Shared Task problem type"
+                ),
+                "num_labels": st.column_config.NumberColumn(
+                    "Number of Labels 🔢", help="Shared Task number of labels"
+                ),
+                "labels": st.column_config.ListColumn(
+                    "Labels 🏷️", help="Shared Task labels"
+                ),
             },
             hide_index=True,
         )
     else:
         st.write("No data found to display on leaderboard 😔.")
 
+
 def create_box_plot_per_task_category(df: pd.DataFrame, id_: str):
     # Compute average performance for each professional category (using professional_mapping).
     melt_vars = []
     for category, tasks in professional_mapping.items():
-        relevant_cols = [col for col in df.columns if "iberbench/" + col in tasks]
+        relevant_cols = [
+            col for col in df.columns if "iberbench/" + col in tasks
+        ]
         if relevant_cols:
             df[category] = df[relevant_cols].mean(axis=1).round(2)
             melt_vars.append(category)
@@ -359,18 +452,31 @@ def create_box_plot_per_task_category(df: pd.DataFrame, id_: str):
     id_vars = model_columns.copy()
     if "language" in df.columns:
         id_vars.append("language")
-    df_melt = df.melt(id_vars=id_vars, value_vars=melt_vars, var_name="Task Category", value_name="Performance")
+    df_melt = df.melt(
+        id_vars=id_vars,
+        value_vars=melt_vars,
+        var_name="Task Category",
+        value_name="Performance",
+    )
     fig = px.box(
-        df_melt, x="Task Category", y="Performance", points="all",
-        labels={"Performance": "Performance (%)"}
+        df_melt,
+        x="Task Category",
+        y="Performance",
+        points="all",
+        labels={"Performance": "Performance (%)"},
+    )
+    st.plotly_chart(
+        fig, use_container_width=True, key=id_ + str(random.random())
     )
-    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
+
 
 def create_box_plot_per_semantic_category(df: pd.DataFrame, id_: str):
     # Compute average performance for each semantic category defined in semantic_categories.
     melt_vars = []
     for category, tasks in semantic_categories.items():
-        relevant_cols = [col for col in df.columns if "iberbench/" + col in tasks]
+        relevant_cols = [
+            col for col in df.columns if "iberbench/" + col in tasks
+        ]
         if relevant_cols:
             df[category] = df[relevant_cols].mean(axis=1).round(2)
             melt_vars.append(category)
@@ -378,19 +484,35 @@ def create_box_plot_per_semantic_category(df: pd.DataFrame, id_: str):
     id_vars = model_columns.copy()
     if "language" in df.columns:
         id_vars.append("language")
-    df_melt = df.melt(id_vars=id_vars, value_vars=melt_vars, var_name="Task Category", value_name="Performance")
+    df_melt = df.melt(
+        id_vars=id_vars,
+        value_vars=melt_vars,
+        var_name="Task Category",
+        value_name="Performance",
+    )
     fig = px.box(
-        df_melt, x="Task Category", y="Performance", points="all",
-        labels={"Performance": "Performance (%)"}
+        df_melt,
+        x="Task Category",
+        y="Performance",
+        points="all",
+        labels={"Performance": "Performance (%)"},
     )
-    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
+    st.plotly_chart(
+        fig, use_container_width=True, key=id_ + str(random.random())
+    )
+
 
 def create_histogram(df: pd.DataFrame, id_: str):
     fig = px.histogram(
-        df, x="num_parameters", nbins=20, labels={"num_parameters": "Num parameters", "count": "Count"},
+        df,
+        x="num_parameters",
+        nbins=20,
+        labels={"num_parameters": "Num parameters", "count": "Count"},
     )
     fig.update_layout(template="plotly_white")
-    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
+    st.plotly_chart(
+        fig, use_container_width=True, key=id_ + str(random.random())
+    )
 
 
 def create_data_results_per_language() -> pd.DataFrame:
@@ -404,7 +526,7 @@ def create_data_results_per_language() -> pd.DataFrame:
                 lang = key.split("leaderboard_data_")[1]
                 temp_df["language"] = lang
             combined_df = pd.concat([combined_df, temp_df], ignore_index=True)
-    
+
     if combined_df.empty:
         st.warning("No data available for any language ⚠️.")
         return
@@ -415,28 +537,36 @@ def create_data_results_per_language() -> pd.DataFrame:
         model_columns = ["model_name", "model_type", "num_parameters"]
         # Exclude metadata, language, and any non-numeric columns.
         performance_cols = [
-            col for col in combined_df.columns 
-            if col not in model_columns + ["language", "Active"] 
+            col
+            for col in combined_df.columns
+            if col not in model_columns + ["language", "Active"]
             and pd.api.types.is_numeric_dtype(combined_df[col])
         ]
         if performance_cols:
-            combined_df["Mean"] = combined_df[performance_cols].mean(axis=1).round(2)
+            combined_df["Mean"] = (
+                combined_df[performance_cols].mean(axis=1).round(2)
+            )
         else:
-            st.warning("No numeric task performance columns available to compute 'Mean' ⚠️.")
+            st.warning(
+                "No numeric task performance columns available to compute 'Mean' ⚠️."
+            )
             return
     return combined_df
-    
-def create_box_plot_per_language(id_: str):    
+
+
+def create_box_plot_per_language(id_: str):
     # Create a boxplot with performance (Mean) per language.
     combined_df = create_data_results_per_language()
     fig = px.box(
-        combined_df, 
-        x="language", 
-        y="Mean", 
+        combined_df,
+        x="language",
+        y="Mean",
         points="all",
         labels={"language": "Language", "Mean": "Performance (%)"},
     )
-    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
+    st.plotly_chart(
+        fig, use_container_width=True, key=id_ + str(random.random())
+    )
 
 
 def get_all_languages_summary_df() -> pd.DataFrame:
@@ -448,7 +578,9 @@ def get_all_languages_summary_df() -> pd.DataFrame:
             task_types = select_task_per_language(lang)
             summary_df = get_summary_df(lang, task_types)
             summary_df["language"] = lang
-            combined_df = pd.concat([combined_df, summary_df], ignore_index=True)
+            combined_df = pd.concat(
+                [combined_df, summary_df], ignore_index=True
+            )
     return combined_df
 
 
@@ -458,14 +590,17 @@ def get_all_languages_aggregated_summary_df() -> pd.DataFrame:
     across languages. Use this aggregated data for radar, scatter, pie, box, and histogram plots.
     """
     df = get_all_languages_summary_df()
-    agg_df = df.groupby("model_name", as_index=False).agg({
-        "model_type": "first",       # choose an aggregation that makes sense
-        "num_parameters": "mean",    # average model size across languages
-        "Mean": "mean",              # average performance
-    })
-    agg_df['Mean']=agg_df['Mean'].round(2)
+    agg_df = df.groupby("model_name", as_index=False).agg(
+        {
+            "model_type": "first",  # choose an aggregation that makes sense
+            "num_parameters": "mean",  # average model size across languages
+            "Mean": "mean",  # average performance
+        }
+    )
+    agg_df["Mean"] = agg_df["Mean"].round(2)
     return agg_df
 
+
 def get_all_languages_raw_df() -> pd.DataFrame:
     """
     Combine the raw leaderboard data from all languages.
@@ -484,8 +619,12 @@ def get_all_languages_raw_df() -> pd.DataFrame:
 # -----------------------------------------------------------------------------
 # Sidebar for Navigation and Global Settings
 # -----------------------------------------------------------------------------
-st.sidebar.markdown("<h2 style='text-align: center;'>IberBench 🌍</h2>", unsafe_allow_html=True)
-menu = st.sidebar.radio("", ["Leaderboard 📊", "Submit Model 🚀", "Datasets 📚", "About ℹ️"])
+st.sidebar.markdown(
+    "<h2 style='text-align: center;'>IberBench 🌍</h2>", unsafe_allow_html=True
+)
+menu = st.sidebar.radio(
+    "", ["Leaderboard 📊", "Submit Model 🚀", "Datasets 📚", "About ℹ️"]
+)
 st.sidebar.markdown("---")
 st.sidebar.markdown(
     """
@@ -496,17 +635,16 @@ st.sidebar.markdown(
     unsafe_allow_html=True,
 )
 
+
 def load_languages_set():
     with open(LANGUAGES_SETTINGS, "r") as f:
         return yaml_load(f)
 
+
 lang_set = load_languages_set()
 
 for lang in lang_set.keys():
-    if lang == "Mixed":
-        data = load_data("Spanish")
-    else:
-        data = load_data(lang)
+    data = load_data(lang)
     if f"leaderboard_data_{lang}" not in st.session_state:
         st.session_state[f"leaderboard_data_{lang}"] = data
 
@@ -514,29 +652,38 @@ for lang in lang_set.keys():
 # Main Content based on Navigation
 # -----------------------------------------------------------------------------
 if menu == "Leaderboard 📊":
-    st.markdown("<div class='main-header'><h1>Leaderboard 📊</h1></div>", unsafe_allow_html=True)
-    lang_iber = [k for k, v in lang_set.items() if v["category"] == "Iberian Peninsula languages"]
+    st.markdown(
+        "<div class='main-header'><h1>Leaderboard 📊</h1></div>",
+        unsafe_allow_html=True,
+    )
+    lang_iber = [
+        k
+        for k, v in lang_set.items()
+        if v["category"] == "Iberian Peninsula languages"
+    ]
     st.markdown("### General ranking 🏆")
-    
+
     # ---------------------------
     # All-language plots section
     # ---------------------------
-     # Use aggregated data for plots where each model must appear once with averaged values.
+    # Use aggregated data for plots where each model must appear once with averaged values.
     aggregated_df = get_all_languages_aggregated_summary_df()
     create_table_all_results(aggregated_df)
     st.markdown("### General plots 📊")
     # Use raw data for Fundamental vs Professional and Task Category plots.
     raw_all_df = get_all_languages_raw_df()
-    all_lang_tabs = st.tabs([
-        "Top 10 performance 🥇",
-        "Performance vs. size 📏",
-        "Type distribution 🎨",
-        "Performance per type 💡",
-        "Distribution of sizes 📊",
-        "Fundamental vs industry ⚖️",
-        "Performance per task category 📈",
-        "Performance per language 🌐",
-    ])
+    all_lang_tabs = st.tabs(
+        [
+            "Top 10 performance 🥇",
+            "Performance vs. size 📏",
+            "Type distribution 🎨",
+            "Performance per type 💡",
+            "Distribution of sizes 📊",
+            "Fundamental vs industry ⚖️",
+            "Performance per task category 📈",
+            "Performance per language 🌐",
+        ]
+    )
     with all_lang_tabs[0]:
         create_radar_chart(aggregated_df, "all_radar")
     with all_lang_tabs[1]:
@@ -554,13 +701,19 @@ if menu == "Leaderboard 📊":
         create_box_plot_per_semantic_category(raw_all_df, "all_box_sem_cat")
     with all_lang_tabs[7]:
         create_box_plot_per_language("all_box_language")
-    
-    # Results per language    
+
+    # Results per language
     st.markdown("---")
     st.markdown("### Language ranking 🏆")
-    lang_choice = st.selectbox("Select a language 🌐:", list(lang_iber), key="lang_leaderboard")
+    lang_choice = st.selectbox(
+        "Select a language 🌐:", list(lang_iber), key="lang_leaderboard"
+    )
     if lang_choice == "Spanish":
-        variations = [k for k, v in lang_set.items() if v["category"] in ["Spanish Variations languages", "Mixed languages"]]
+        variations = [
+            k
+            for k, v in lang_set.items()
+            if v["category"] in ["Spanish Variations languages"]
+        ]
         tabs_var = st.tabs(variations)
         for var, tab in zip(variations, tabs_var):
             with tab:
@@ -569,11 +722,15 @@ if menu == "Leaderboard 📊":
         create_results_visualization_lang(lang_choice)
 
 elif menu == "Submit Model 🚀":
-    st.markdown("<div class='main-header'><h1>Submit Your Model 🚀</h1></div>", unsafe_allow_html=True)
+    st.markdown(
+        "<div class='main-header'><h1>Submit Your Model 🚀</h1></div>",
+        unsafe_allow_html=True,
+    )
     st.markdown("## How to submit a model 📤")
 
     # CSS
-    st.markdown("""
+    st.markdown(
+        """
         <style>
             .card-container {
                 max-width: 300px;
@@ -611,7 +768,9 @@ elif menu == "Submit Model 🚀":
                 margin-left: 8px;
             }
         </style>
-    """, unsafe_allow_html=True)
+    """,
+        unsafe_allow_html=True,
+    )
 
     def render_card(content):
         html = f"""
@@ -643,7 +802,10 @@ elif menu == "Submit Model 🚀":
             index = row * num_columns + col
             if index < len(guide_info_list):
                 with cols[col]:
-                    st.markdown(render_card(guide_info_list[index]), unsafe_allow_html=True)
+                    st.markdown(
+                        render_card(guide_info_list[index]),
+                        unsafe_allow_html=True,
+                    )
 
     st.markdown("## Submission form 📝")
     with st.form("submit_model_form", clear_on_submit=True):
@@ -655,7 +817,10 @@ elif menu == "Submit Model 🚀":
             "Description ✍️",
             help="Add a description of the proposed model for the evaluation to help prioritize its evaluation.",
         )
-        user_contact = st.text_input("Your Contact Email 📧", help="User e-mail to contact when there are updates.")
+        user_contact = st.text_input(
+            "Your Contact Email 📧",
+            help="User e-mail to contact when there are updates.",
+        )
         precision_option = st.selectbox(
             "Choose precision format 🔢:",
             help="Size limits vary by precision. Choose carefully as incorrect precision can cause evaluation errors.",
@@ -668,7 +833,11 @@ elif menu == "Submit Model 🚀":
             options=["Original", "Adapter", "Delta"],
             index=0,
         )
-        base_model_name = st.text_input("Base model (if applicable) 🏗️", help="Required for delta weights or adapters. This helps calculate total parameter count.", value="")
+        base_model_name = st.text_input(
+            "Base model (if applicable) 🏗️",
+            help="Required for delta weights or adapters. This helps calculate total parameter count.",
+            value="",
+        )
         model_type = st.selectbox(
             "Choose model type 🔍:",
             help="🟢 Pretrained: Base models, 🔶 Fine-tuned: Domain-specific, 💬 Chat: Conversational, 🤝 Merge: Combined weights.",
@@ -678,7 +847,11 @@ elif menu == "Submit Model 🚀":
         if submit_button:
             use_chat_template = True if model_type == "💬 Chat" else False
             validation_error = validate_model(
-                model_name, precision_option, base_model_name, weight_type_option, use_chat_template
+                model_name,
+                precision_option,
+                base_model_name,
+                weight_type_option,
+                use_chat_template,
             )
             if validation_error is not None:
                 st.error(validation_error)
@@ -698,121 +871,62 @@ elif menu == "Submit Model 🚀":
                     log_submission(input_dict)
                     st.success("Your request has been sent successfully 🎉.")
                 except Exception as e:
-                    st.error(f"Failed to send your request: {e}. Please try again later.")
+                    st.error(
+                        f"Failed to send your request: {e}. Please try again later."
+                    )
 
 elif menu == "Datasets 📚":
-    st.markdown("<div class='main-header'><h1>Dataset Information 📚</h1></div>", unsafe_allow_html=True)
+    st.markdown(
+        "<div class='main-header'><h1>Dataset Information 📚</h1></div>",
+        unsafe_allow_html=True,
+    )
     st.markdown("### Check the datasets 🔍")
-    lang_iber = [k for k, v in lang_set.items() if v["category"] == "Iberian Peninsula languages"]
-    lang_choice = st.selectbox("Select a language 🌐:", list(lang_iber), key="lang_dataset")
-    if lang_choice == "Spanish":
-        variations = [k for k, v in lang_set.items() if v["category"] in ["Spanish Variations languages", "Mixed languages"]]
+    lang_iber = [
+        k
+        for k, v in lang_set.items()
+        if v["category"] == "Iberian Peninsula languages"
+    ]
+    lang_choice = st.selectbox(
+        "Select a language 🌐:", list(lang_iber), key="lang_dataset"
+    )
+    if lang_choice in ["Spanish"]:
+        variations = [
+            k
+            for k, v in lang_set.items()
+            if v["category"] in ["Spanish Variations languages"]
+        ]
         tabs_var = st.tabs(variations)
         for var, tab in zip(variations, tabs_var):
             with tab:
-                if var == "Mixed":
-                    create_dataset_info_per_language("Spanish")
-                else:
-                    create_dataset_info_per_language(var)
+                create_dataset_info_per_language(var)
     else:
         create_dataset_info_per_language(lang_choice)
     st.markdown("### Task mappings 🔄")
-    st.markdown("For the sake of completeness, here we show the mappings we use in the leaderboard to aggregate tasks.")
-    tab1, tab2 = st.tabs(["Semantic categories 🗂️", "Fundamental vs. Industry ⚖️"])
+    st.markdown(
+        "For the sake of completeness, here we show the mappings we use in the leaderboard to aggregate tasks."
+    )
+    tab1, tab2 = st.tabs(
+        ["Semantic categories 🗂️", "Fundamental vs. Industry ⚖️"]
+    )
     with tab1:
-        st.json({category: [task.removeprefix("iberbench/") for task in tasks] for category, tasks in semantic_categories.items()})
+        st.json(
+            {
+                category: [task.removeprefix("iberbench/") for task in tasks]
+                for category, tasks in semantic_categories.items()
+            }
+        )
     with tab2:
-        st.json({category: [task.removeprefix("iberbench/") for task in tasks] for category, tasks in professional_mapping.items()})
+        st.json(
+            {
+                category: [task.removeprefix("iberbench/") for task in tasks]
+                for category, tasks in professional_mapping.items()
+            }
+        )
 
 elif menu == "About ℹ️":
-    st.markdown("<div class='main-header'><h1>About ℹ️</h1></div>", unsafe_allow_html=True)
-    st.markdown("""### 📖 What is IberBench?
-IberBench is a hub comprised of datasets for languages across Iberian and Latin American regions, aimed to be used as a benchmark to evaluate causal language models. This initiative aims to enrich the Natural Language Processing (NLP) community in the Iberian Peninsula and Latin America. The benchmark enables the evaluation of NLP models in multiple Spanish variants and other languages such as Catalan, Galician, Basque, Portuguese, and Latin American Spanish, fostering assessments and developments that reflect the linguistic diversity of these regions.
-
-We hope to drive multilingual research that considers the cultural and linguistic richness and complexity of the Spanish-speaking world, encouraging the creation of models that are truly representative of these realities. 
-
-### 📂 What are the data sources?
-
-IberBench contains datasets from prominent workshops in the field such as [IberLEF@SEPLN](https://sepln2024.infor.uva.es/eventos/iberlef-es/) or [PAN@CLEF](https://pan.webis.de/clef24/pan24-web/index.html), as well as stablished existing benchmarks as those from HiTZ, UPF, BSC, CiTIUS-USC, among others, with the aim to incorporate standardized and consistent evaluation within this context, enhancing the value of the data and models derived from this effort.
-
-We strictly adhere to all established guidelines and regulations concerning the use and publication of this data. Specifically:
-
-- The collected datasets are published on 🤗HuggingFace private repositories, with appropriate credit given to the authors in the model card.
-- Under no circumstances we claim ownership of the datasets.
-- The test splits of the datasets are kept private to avoid leakage from IberBench side.
-
-In any publication or presentation resulting from work with this data, we recognize the importance of citing and crediting to the organizing teams that crafted the datasets used at IberBench.
-
-### 🙋 How can I join to IberBench?
-
-IberBench comprises a committee composed of specialists in NLP, language ethics, and gender discrimination, drawn from both academia and industry, which will oversee the development of the project, ensuring its quality and relevance.
-
-To be part of this committee, you can ask to join the [IberBench organization at 🤗HuggingFace](https://huggingface.co/iberbench). Your request will be validated by experts already belonging to the organization.
-
-### 🤝 How can I contribute to IberBench?
-
-First, the initial committee will gather all the datasets from prominent workshops. From this, you can contribute with new datasets to the IberBench organization. The process is as follows:
-
-1. Open a new discussion in the [IberBench discussions space](https://huggingface.co/spaces/iberbench/README/discussions), linking to an existing dataset in the 🤗HuggingFace hub and explaining why the inclusion is relevant.
-2. Discuss with the committee for the approval or rejection of the dataset.
-3. If approval: your dataset will be included into the IberBench datasets, and will be used to evaluate LLMs in the IberBench leaderboard.
-
-IberBench will never claim ownership over the dataset, the original author will receive all credits.
-
-### 💬 Social networks
-
-You can reach us at:
-
-- **X**: [https://x.com/IberBench](https://x.com/IberBench)
-- **🤗 Discussions**: [https://huggingface.co/spaces/iberbench/README/discussions](https://huggingface.co/spaces/iberbench/README/discussions)
-
-### 🫶 Acknowledgements
-
-We are incredibly grateful to the amazing teams behind the datasets from workshops like IberLEF, IberEval, and TASS under the umbrella of the [SEPLN](http://www.sepln.org/sepln), as well as the established benchmarks from HiTZ, UPF, BSC, CiTIUS-USC, among others. Their hard work and dedication to advancing NLP have made this benchmark possible. Huge thanks for sharing your invaluable resources with the community! 🚀👏
-             
-IberBench has been funded by the Valencian Institute for Business Competitiveness (IVACE). </br>
-            
-<style>
-    body {
-        margin: 0;
-        display: flex;
-        flex-direction: column;
-        min-height: 100vh;
-    }
-    .footer {
-        margin-top: auto;
-        display: flex;
-        flex-direction: column;
-        align-items: center;
-        text-align: center;
-        width: 100%;
-        background: white;
-        padding: 5px 0;
-    }
-    .footer p {
-        margin: 0;
-        font-size: 16px;
-    }
-    .logos {
-        display: flex;
-        justify-content: center;
-        align-items: center; /* Align images properly */
-        gap: 20px;
-    }
-    .logos img {
-        display: block;
-        margin: 0;
-        padding: 0;
-        max-height: 100px; /* Ensures both images have the same height */
-        width: auto; /* Keeps aspect ratio */
-    }
-</style>
-</br>
-<div class="footer">
-    <p>Developed by Symanto with ❤️</p>
-    <div class="logos">
-        <img src="https://www.ivace.es/images/logo2-ivace.PNG">
-        <img src="https://www.symanto.com/wp-content/uploads/Logos/symanto.svg">
-    </div>
-</div>
-    """, unsafe_allow_html=True)
+    st.markdown(
+        "<div class='main-header'><h1>About ℹ️</h1></div>",
+        unsafe_allow_html=True,
+    )
+    with open("./assets/md/about.md", "r") as fr:
+        st.markdown(fr.read(), unsafe_allow_html=True)

etc/languages_settings.yml

@@ -10,8 +10,8 @@ Galician:
     category: 'Iberian Peninsula languages'
 English:
     category: 'Iberian Peninsula languages'
-Mixed:
-    category: 'Mixed languages'
+Spanish Mixed:
+    category: 'Spanish Variations languages'
 Costa Rica:
     category: 'Spanish Variations languages'
 Mexico: