From internal repo to HF

README.md

@@ -1,5 +1,5 @@
 ---
-title: Ivace Leaderboard
+title: IberBench Leaderboard
 emoji: 👀
 colorFrom: purple
 colorTo: gray
@@ -8,7 +8,7 @@ sdk_version: 1.41.1
 app_file: app.py
 pinned: false
 license: mit
-short_description: IVACE leaderboard
+short_description: IberBench leaderboard
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -2,39 +2,76 @@ import json
 import os
 import re
 import uuid
+import random
 from pathlib import Path
 
 import pandas as pd
 import streamlit as st
+import plotly.express as px
+
 from datasets import load_dataset
-from huggingface_hub import CommitScheduler
+from huggingface_hub import CommitScheduler, hf_hub_download
+from huggingface_hub.utils import RepositoryNotFoundError
+from yaml import safe_load as yaml_load
 
 from src.check_validity import validate_model
+from src.task_mappings import professional_mapping, semantic_categories
 
-# define page config
-st.set_page_config(page_title="IberBench Leaderboard", layout="wide")
+# -----------------------------------------------------------------------------
+# 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="🌍")
 
-# setup scheduler to upload user requests
+st.markdown(
+    """
+    <style>
+    /* General page styling */
+    body {
+        background-color: #f7f7f7;
+        font-family: 'Segoe UI', sans-serif;
+    }
+    /* Sidebar styling */
+    .css-1d391kg {
+        background-color: #ffffff;
+        border-right: 2px solid #eaeaea;
+    }
+    /* Header styling */
+    .main-header {
+        text-align: center;
+        padding: 2rem 0;
+        background: linear-gradient(90deg, #007BFF, #00BFFF);
+        color: white;
+        border-radius: 10px 10px 10px 10px;
+    }
+    /* Tab styling */
+    .stTabs > .css-1qimj2v { 
+        background: #fff;
+    }
+    /* Form styling */
+    .stButton>button {
+        background-color: #007BFF;
+        color: white;
+        border: none;
+        border-radius: 5px;
+    }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+# -----------------------------------------------------------------------------
+# Global variables and helper functions
+# -----------------------------------------------------------------------------
 request_file = Path("user_request/") / f"data_{uuid.uuid4()}.json"
 request_folder = request_file.parent
 
+LANGUAGES_SETTINGS = Path("etc/languages_settings.yml")
 
-# columns = [
-#     "eval_name",
-#     "Model",
-#     "Type",
-#     "Average ⬆️",
-#     "IFEval",
-#     "MMLU-PRO",
-#     "GPQA",
-#     "MUSR",
-#     "CO₂ cost (kg)",
-# ]
-# languages
-lang_list = ["Spain", "Portuguese", "English", "Spanish", "Costa Rica", "Mexico", "Peru", "Uruguay", "Basque", "Catalan", "Galician"]
-
-# column order
-model_columns = ["model_name", "url", "type"]
+dataset_columns = [
+    "workshop", "shared_task", "year", "task_type", "language", 
+    "url", "language_variety", "problem_type", "num_labels", "labels",
+]
+model_columns = ["model_name", "model_type", "num_parameters"]
 
 scheduler = CommitScheduler(
     repo_id="iberbench/user-requests",
@@ -46,247 +83,607 @@ scheduler = CommitScheduler(
     every=10,
 )
 
-
 def log_submission(input_dict: dict) -> None:
-    """
-    Append input/outputs and user feedback to a JSON Lines file using a thread lock to avoid concurrent writes from different users.
-    """
     with scheduler.lock:
         with request_file.open("a") as f:
             f.write(json.dumps(input_dict))
             f.write("\n")
 
-
-# def get_url(html_content: str) -> str:
-#     match = re.search(r'href=["\'](https?://[^\s"\']+)', html_content)
-#     if match:
-#         url = match.group(1)
-#         return url
-#     else:
-#         raise ValueError("Url not found in the link")
-
-
 def get_lang_columns(columns: list, lang: str):
-    """Filter columns per language"""
     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()
-        )
-        # filter lang columns
+        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 = data[model_columns + task_lang_columns]
-
-        # data["Model"] = data["Model"].apply(get_url)
-        # data.sort_values(by="Average ⬆️", ascending=False, inplace=True)
-        # data.reset_index(drop=True, inplace=True)
-
-        # add column to apply filtering
-        data["Active"] = False
-
+        #data["Active"] = False
         return data
     except FileNotFoundError:
-        st.error("iberbench/lm-eval-results was not found in the hub")
+        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:
+        info_path = hf_hub_download(
+            repo_id=name_repo,
+            filename="task_metadata.json",
+            repo_type="dataset",
+        )
+        with open(info_path, "r") as f:
+            info = json.load(f)
+        values_ = []
+        for i in dataset_columns:
+            if i in info:
+                values_.append(info[i])
+            else:
+                values_.append([] if i == "labels" else "-")
+        return values_
+    except RepositoryNotFoundError:
+        st.error(task + ": dataset was not found in the hub 🚫")
+        return ["-"] * len(dataset_columns)
 
-# functions to create filter
-def active_data(lang) -> pd.DataFrame:
-    """Change all records as active"""
-    return st.session_state[f"leaderboard_data_{lang}"][
-        st.session_state[f"leaderboard_data_{lang}"]["Active"] == True
-    ].copy()
 
+def active_data(lang) -> pd.DataFrame:
+    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:
-    """Get index of the row"""
     return active_data(lang).iloc[row].name
 
-
 def commit(lang) -> None:
-    """Commit changes to the session state"""
     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
+
+
+# -----------------------------------------------------------------------------
+# Visualization helper functions
+# -----------------------------------------------------------------------------
+def create_table_results(df_mean: pd.DataFrame):
+    rank_value = []
+    for i in df_mean["Mean"].rank(method="dense", ascending=False).astype(int):
+        if i == 1:
+            rank_value.append(f"{i} 🥇")
+        elif i == 2:
+            rank_value.append(f"{i} 🥈")
+        elif i == 3:
+            rank_value.append(f"{i} 🥉")
+        else:
+            rank_value.append(str(i))
+    df_mean.insert(0, "Rank", rank_value)
+    df_final = df_mean.sort_values("Mean", ascending=False)
+    st.dataframe(
+        df_final,
+        hide_index=True,
+        use_container_width=True,
+        column_config={
+            "model_name": st.column_config.TextColumn("Model 🧠"),
+            "model_type": st.column_config.TextColumn("Type 📌"),
+            "num_parameters": st.column_config.NumberColumn("Model Size 🔢"),
+        },
+    )
 
 
-def create_search_per_language(lang: str, search_dict: dict):
-    if not st.session_state[f"leaderboard_data_{lang}"].empty:
-        search_dict[lang] = st.text_input(
-            "Search for ...",
-            key=f"search_input_{lang}",
-            on_change=commit,
-            kwargs={"lang": lang},
-        )
-        if search_dict[lang] == "":
-            st.session_state[f"leaderboard_data_{lang}"].Active = True
+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
+    rank_value = []
+    for i in aggregated_df["Mean"].rank(method="dense", ascending=False).astype(int):
+        if i == 1:
+            rank_value.append(f"{i} 🥇")
+        elif i == 2:
+            rank_value.append(f"{i} 🥈")
+        elif i == 3:
+            rank_value.append(f"{i} 🥉")
         else:
-            st.session_state[f"leaderboard_data_{lang}"].Active = False
-            st.session_state[f"leaderboard_data_{lang}"].loc[
-                st.session_state[f"leaderboard_data_{lang}"][
-                    "model_name"
-                ].str.contains(search_dict[lang], case=False),
-                "Active",
-            ] = True
-
-        # select columns to display
-        task_columns = [col for col in st.session_state[f"leaderboard_data_{lang}"].columns if col not in model_columns]
-        task_lang_columns = get_lang_columns(task_columns, lang)
-        columns = model_columns + task_lang_columns
-
-        edited_data = st.data_editor(
-            active_data(lang),
-            column_order=columns,
-            key=f"edited_data_{lang}",
-            hide_index=False,
-            # column_config={"Model": st.column_config.LinkColumn("Model")},
-            column_config={"url": st.column_config.LinkColumn("url")},
-        )
-    else:
-        st.write("No data found to display on leaderboard.")
+            rank_value.append(str(i))
+    aggregated_df.insert(0, "Rank", rank_value)
+    df_final = aggregated_df.sort_values("Mean", ascending=False)
+    st.dataframe(
+        df_final,
+        hide_index=True,
+        use_container_width=True,
+        column_config={
+            "model_name": st.column_config.TextColumn("Model 🧠"),
+            "model_type": st.column_config.TextColumn("Type 📌"),
+            "num_parameters": st.column_config.NumberColumn("Model Size 🔢"),
+        },
+    ) 
+
+
+def create_scatter_chart(df: pd.DataFrame, id_: str):
+    fig = px.scatter(
+        df,
+        x="num_parameters",
+        y="Mean",
+        color="model_name",
+        size="num_parameters",
+        hover_data=["model_type"],
+        labels={"num_parameters": "Num parameters"}
+    )
+    fig.update_layout(template="plotly_white")
+    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]
+    })
+    fig = px.line_polar(
+        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()))
 
 
-# streamlit UI
-for lang in lang_list:
-    # todo: load a different dataset per language of load different column per lang
-    leaderboard_data = load_data(lang)
-    if f"leaderboard_data_{lang}" not in st.session_state:
-        st.session_state[f"leaderboard_data_{lang}"] = leaderboard_data
+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"}
+    )
+    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
 
-tabs = st.tabs(["Leaderboard", "Submit model"])
-search_dict = {}
 
-with tabs[0]:
-    # logo image
-    cols_logo = st.columns(5, vertical_alignment="center")
-    with cols_logo[2]:
-        st.image("assets/images/hf-logo.png", use_container_width=True)
+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"}
+    )
+    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
 
-    # title
-    st.markdown(
-        """
-        <div style="text-align: center;">
-            <h1>IberBench LLM Leaderboard</h1>
-            <p style="font-size: 1.2rem;">
-                Comparing Large Language Models in an <span style="font-weight: 600;">open</span> 
-                and <span style="font-weight: 600;">reproducible</span> way
-            </p>
-        </div>
-        """,
-        unsafe_allow_html=True,
+
+def get_summary_df(lang: str, task_types: list) -> pd.DataFrame:
+    df = st.session_state[f"leaderboard_data_{lang}"][model_columns].copy()
+    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]
+            if cols:
+                tmp = st.session_state[f"leaderboard_data_{lang}"][cols]
+                df[t] = tmp.mean(axis=1).round(2)
+        if df.shape[1] > 4:
+            df.insert(3, "Mean", df.iloc[:, 3:-1].mean(axis=1).round(2))
+        else:
+            df.insert(3, "Mean", df.iloc[:, 3].round(2))
+    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()
+    for key in st.session_state:
+        if key.startswith("leaderboard_data_"):
+            lang = key.split("leaderboard_data_")[1]
+            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)
+    return combined_df
+
+
+def create_results_visualization_lang(lang: str):
+    # ---------------------------
+    # In-language plots section
+    # ---------------------------
+    task_types = select_task_per_language(lang)
+    summary_df = get_summary_df(lang, task_types)
+    tasks_df = st.session_state[f"leaderboard_data_{lang}"].copy()
+    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 📈",
+    ])
+    with in_lang_tabs[0]:
+        create_radar_chart(summary_df, lang + "in_radar")
+    with in_lang_tabs[1]:
+        create_scatter_chart(summary_df, lang + "in_scatter")
+    with in_lang_tabs[2]:
+        create_box_plot(summary_df, lang + "in_box")
+    with in_lang_tabs[3]:
+        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 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]
+        if len(cols) > 1:
+           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)
+        df = pd.DataFrame(all_values, columns=dataset_columns)
+        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"),
+            },
+            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]
+        if relevant_cols:
+            df[category] = df[relevant_cols].mean(axis=1).round(2)
+            melt_vars.append(category)
+    melt_vars = list(set(melt_vars))
+    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")
+    fig = px.box(
+        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()))
+
+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]
+        if relevant_cols:
+            df[category] = df[relevant_cols].mean(axis=1).round(2)
+            melt_vars.append(category)
+    melt_vars = list(set(melt_vars))
+    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")
+    fig = px.box(
+        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()))
+
+def create_histogram(df: pd.DataFrame, id_: str):
+    fig = px.histogram(
+        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()))
+
+
+def create_data_results_per_language() -> pd.DataFrame:
+    # Create a combined dataframe from all leaderboard data in session_state.
+    combined_df = pd.DataFrame()
+    for key in st.session_state.keys():
+        if key.startswith("leaderboard_data_"):
+            temp_df = st.session_state[key].copy()
+            # If the "language" column is missing, use the key to assign a language name.
+            if "language" not in temp_df.columns:
+                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
+
+    # Check if the "Mean" column exists. If not, compute it.
+    if "Mean" not in combined_df.columns:
+        # Define model metadata columns that should be excluded from the performance calculation.
+        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"] 
+            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)
+        else:
+            st.warning("No numeric task performance columns available to compute 'Mean' ⚠️.")
+            return
+    return combined_df
+    
+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", 
+        points="all",
+        labels={"language": "Language", "Mean": "Performance (%)"},
+    )
+    st.plotly_chart(fig, use_container_width=True, key=id_ + str(random.random()))
+
 
-    # create tabs per language
-    lang_tabs = st.tabs(lang_list)
+def get_all_languages_summary_df() -> pd.DataFrame:
+    """Combine leaderboard summary data from all languages using get_summary_df."""
+    combined_df = pd.DataFrame()
+    for key in st.session_state:
+        if key.startswith("leaderboard_data_"):
+            lang = key.split("leaderboard_data_")[1]
+            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)
+    return combined_df
 
-    for lang, lt in zip(lang_list, lang_tabs):
-        with lt:
-            create_search_per_language(lang, search_dict)
 
+def get_all_languages_aggregated_summary_df() -> pd.DataFrame:
+    """
+    Aggregate the combined summary data by model_name to compute mean performance
+    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)
+    return agg_df
+
+def get_all_languages_raw_df() -> pd.DataFrame:
+    """
+    Combine the raw leaderboard data from all languages.
+    This is used for plots (e.g., Fundamental vs Professional) that rely on the original task columns.
+    """
+    combined_df = pd.DataFrame()
+    for key in st.session_state:
+        if key.startswith("leaderboard_data_"):
+            lang = key.split("leaderboard_data_")[1]
+            temp_df = st.session_state[key].copy()
+            temp_df["language"] = lang
+            combined_df = pd.concat([combined_df, temp_df], ignore_index=True)
+    return combined_df
+
+
+# -----------------------------------------------------------------------------
+# 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("---")
+st.sidebar.markdown(
+    """
+    <p style="font-size:0.9rem; text-align:center;">
+    A leaderboard of LLMs on languages from the Iberian Peninsula and Ibero-America
+    </p>
+    """,
+    unsafe_allow_html=True,
+)
+
+def load_languages_set():
+    with open(LANGUAGES_SETTINGS, "r") as f:
+        return yaml_load(f)
 
-with tabs[1]:
-    st.header("Submit model")
+lang_set = load_languages_set()
 
-    def get_id_number(id_val):
-        html_template = f"""
-        <div style="display: flex; align-items: flex-start; margin-bottom: 1rem;">
-            <div style="
-                width: 32px; 
-                height: 32px; 
-                border-radius: 50%; 
-                display: flex; 
+for lang in lang_set.keys():
+    if lang == "Mixed":
+        data = load_data("Spanish")
+    else:
+        data = load_data(lang)
+    if f"leaderboard_data_{lang}" not in st.session_state:
+        st.session_state[f"leaderboard_data_{lang}"] = data
+
+# -----------------------------------------------------------------------------
+# 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("### General ranking 🏆")
+    
+    # ---------------------------
+    # All-language plots section
+    # ---------------------------
+     # 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 🌐",
+    ])
+    with all_lang_tabs[0]:
+        create_radar_chart(aggregated_df, "all_radar")
+    with all_lang_tabs[1]:
+        create_scatter_chart(aggregated_df, "all_scatter")
+    with all_lang_tabs[2]:
+        create_pie_chart(aggregated_df, "all_pie")
+    with all_lang_tabs[3]:
+        create_box_plot(aggregated_df, "all_box")
+    with all_lang_tabs[4]:
+        create_histogram(aggregated_df, "all_hist")
+    with all_lang_tabs[5]:
+        # Use the raw combined data so that professional task columns are available.
+        create_box_plot_per_task_category(raw_all_df, "all_box_task_cat")
+    with all_lang_tabs[6]:
+        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    
+    st.markdown("---")
+    st.markdown("### Language ranking 🏆")
+    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"]]
+        tabs_var = st.tabs(variations)
+        for var, tab in zip(variations, tabs_var):
+            with tab:
+                create_results_visualization_lang(var)
+    else:
+        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("## How to submit a model 📤")
+
+    # CSS
+    st.markdown("""
+        <style>
+            .card-container {
+                max-width: 300px;
+                margin: auto;
+                text-align: left;
+                font-size: 1rem;
+                padding: 0.5rem;
+                box-sizing: border-box;
+            }
+            .id-container {
+                display: flex;
                 align-items: center; 
-                justify-content: center; 
-                border: 1px solid #007BFF; 
-                color: #007BFF; 
-                font-size: 0.875rem; 
-                font-weight: 600; 
-                background-color: transparent;">
-                {id_val}
-            </div>"""
-        return html_template
-
-    # create guide info
+                margin-bottom: 1rem;
+            }
+            .id-circle {
+                width: 32px;
+                height: 32px;
+                border-radius: 50%;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                border: 1px solid #007BFF;
+                color: #007BFF;
+                font-size: 0.875rem;
+                font-weight: 600;
+                background-color: transparent;
+                margin-right: 8px; 
+            }
+            .guide-content {
+                word-wrap: break-word;
+            }
+            .guide-title {
+                font-weight: bold;
+                font-size: 1rem;
+                margin-left: 8px;
+            }
+        </style>
+    """, unsafe_allow_html=True)
+
+    def render_card(content):
+        html = f"""
+        <div class="card-container">
+            <div class="guide-content">
+                {content}
+            </div>
+        </div>
+        """
+        return html
+
+    # Load your HTML content from files
     guide_info_list = []
     html_path = "assets/html"
-    for filename in os.listdir(html_path):
+    filenames = sorted(os.listdir(html_path))
+    for filename in filenames:
         file_path = os.path.join(html_path, filename)
         with open(file_path, "r", encoding="utf-8") as file:
-            guide_info_list.append(file.read())
-
-    # display adding number id
-    for i, info_div in enumerate(guide_info_list):
-        st.markdown(get_id_number(i + 1) + info_div, unsafe_allow_html=True)
-
-    with st.form("submit_model_form"):
+            raw_html = file.read()
+            guide_info_list.append(raw_html)
+
+    # Create the grid
+    num_columns = 3
+    num_rows = 2
+
+    for row in range(num_rows):
+        cols = st.columns(num_columns)
+        for col in range(num_columns):
+            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("## Submission form 📝")
+    with st.form("submit_model_form", clear_on_submit=True):
         model_name = st.text_input(
-            "Model Name (format: user_name/model_name)",
+            "Model Name (format: user_name/model_name) 🧩",
             help="Your model should be public on the Hub and follow the username/model-id format (e.g. mistralai/Mistral-7B-v0.1).",
         )
         description = st.text_area(
-            "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",
+            "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.")
         precision_option = st.selectbox(
-            "Choose precision format:",
-            help="Size limits vary by precision: • FP16/BF16: up to 100B parameters • 8-bit: up to 280B parameters (2x) • 4-bit: up to 560B parameters (4x) Choose carefully as incorrect precision can cause evaluation errors.",
+            "Choose precision format 🔢:",
+            help="Size limits vary by precision. Choose carefully as incorrect precision can cause evaluation errors.",
             options=["float16", "bfloat16", "8bit", "4bit", "GPTQ"],
             index=0,
         )
         weight_type_option = st.selectbox(
-            "Select what type of weights are being loaded from the checkpoint provided:",
-            help="Original: Complete model weights in safetensors format Delta: Weight differences from base model (requires base model for size calculation) Adapter: Lightweight fine-tuning layers (requires base model for size calculation)",
+            "Select weight type ⚖️:",
+            help="Original: Complete model weights. Delta: Differences from base model. Adapter: Lightweight fine-tuning layers.",
             options=["Original", "Adapter", "Delta"],
             index=0,
         )
-        base_model_name = st.text_input(
-            "Base model",
-            help="Required for delta weights or adapters. This information is used to identify the original model and calculate the total parameter count by combining base model and adapter/delta parameters.",
-            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 trained on text using masked modeling 🔶 Fine-tuned: Domain-specific optimization 💬 Chat: Models using RLHF, DPO, or IFT for conversation 🤝 Merge: Combined weights without additional training",
-            options=[
-                "🟢 Pretrained",
-                "🔶 Fine-tuned",
-                "💬 Chat",
-                "🤝 Merge",
-            ],
+            "Choose model type 🔍:",
+            help="🟢 Pretrained: Base models, 🔶 Fine-tuned: Domain-specific, 💬 Chat: Conversational, 🤝 Merge: Combined weights.",
+            options=["🟢 Pretrained", "🔶 Fine-tuned", "💬 Chat", "🤝 Merge"],
         )
-        submit_button = st.form_submit_button("Submit Request")
-
+        submit_button = st.form_submit_button("Submit Request 🚀")
         if submit_button:
-            # validate model size, license, chat_templates
             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)
             elif not re.match(r"[^@]+@[^@]+\.[^@]+", user_contact):
-                st.error("Invalid email address.")
+                st.error("Invalid email address ⚠️.")
             else:
                 input_dict = {
                     "model_name": model_name,
@@ -299,8 +696,123 @@ with tabs[1]:
                 }
                 try:
                     log_submission(input_dict)
-                    st.success("Your request has been sent successfully.")
+                    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("### 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"]]
+        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)
+    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 ⚖️"])
+    with tab1:
+        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()})
+
+elif menu == "About ℹ️":
+    st.markdown("<div class='main-header'><h1>About ℹ️</h1></div>", unsafe_allow_html=True)
+    st.markdown("""### 📖 What is IberBench?
+IberBench is 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)

assets/html/01_model_info.html

@@ -1,12 +1,9 @@
-<div style="margin-left: 10px;">
-  <h4 style="margin: 0; color: #007BFF;">Model Information</h4>
-  <p>
-    Your model should be <strong>public</strong> on the Hub and follow the
-    <strong>username/model-id</strong> format (e.g., mistralai/Mistral-7B-v0.1).
-    Specify the <strong>revision</strong> (commit hash or branch) and <strong>model type</strong>.
-  </p>
-  <a href="https://huggingface.co/docs/hub/models-uploading" target="_blank"
-     style="color: #007BFF; text-decoration: underline; font-family: monospace;">
-     Model uploading guide →
-  </a>
-</div>
+<h4 style="margin: 0; color: #007BFF;">Model Information</h4>
+<p style="font-size: 0.875rem; color: #6c757d; margin: 0; line-height: 1.5;">
+  Your model should be <strong>public</strong> on the Hub and follow the
+  <strong>username/model-id</strong> format (e.g., mistralai/Mistral-7B-v0.1).
+</p>
+<a href="https://huggingface.co/docs/hub/models-uploading" target="_blank"
+    style="color: #007BFF; text-decoration: underline; font-family: monospace;">
+    Model uploading guide →
+</a>

assets/html/02_technical_detail.html

@@ -1,17 +1,5 @@
-<div style="margin-left: 10px;">
-  <h4 style="margin: 0; color: #007BFF;">Technical Details</h4>
-  <p style="font-size: 0.875rem; color: #6c757d; margin: 0; line-height: 1.5;">
-    Make sure your model can be <strong>loaded locally</strong> before submitting:
-  </p>
-  <div style="background-color: #f5f5f5; padding: 1rem; border-radius: 5px; font-family: monospace; color: #212529;">
-    <pre style="margin: 0; padding: 0; font-size: 1rem; white-space: pre-wrap; word-wrap: break-word;">
-      <code>
-from transformers import AutoConfig, AutoModel, AutoTokenizer
-config = AutoConfig.from_pretrained("your-username/your-model", revision="main")
-model = AutoModel.from_pretrained("your-username/your-model", revision="main")
-tokenizer = AutoTokenizer.from_pretrained("your-username/your-model", revision="main")
-      </code>
-    </pre>
-  </div>
-  <a href="https://huggingface.co/docs/transformers/installation" target="_blank" style="color: #007BFF; text-decoration: underline; font-family: monospace;">Transformers documentation →</a>
-</div>
+<h4 style="margin: 0; color: #007BFF;">Technical Details</h4>
+<p style="font-size: 0.875rem; color: #6c757d; margin: 0; line-height: 1.5;">
+  Make sure your model can be <strong>loaded locally</strong> with `AutoModel` before submitting:
+</p>
+<a href="https://huggingface.co/docs/transformers/installation" target="_blank" style="color: #007BFF; text-decoration: underline; font-family: monospace;">Transformers documentation →</a>

assets/html/03_licenses.html

@@ -0,0 +1,6 @@
+<h4 style="margin: 0; color: #007BFF;">License Requirements</h4>
+<p style="font-size: 0.875rem; color: #6c757d;">
+  A <strong>license tag</strong> is required. <strong>Open licenses</strong>
+  (Apache, MIT, etc) are strongly recommended.
+</p>
+<a href="https://huggingface.co/docs/hub/repositories-licenses" target="_blank" style="color: #007BFF; text-decoration: underline; font-family: monospace;">About model licenses →</a>

assets/html/03_linceses.html

@@ -1,8 +0,0 @@
-<div style="margin-left: 10px;">
-  <h4 style="margin: 0; color: #007BFF;">License Requirements</h4>
-  <p style="font-size: 0.875rem; color: #6c757d;">
-    A <strong>license tag</strong> is required. <strong>Open licenses</strong>
-    (Apache, MIT, etc) are strongly recommended.
-  </p>
-<a href="https://huggingface.co/docs/hub/repositories-licenses" target="_blank" style="color: #007BFF; text-decoration: underline; font-family: monospace;">About model licenses →</a>
-</div>

assets/html/04_model_card.html

@@ -1,9 +1,7 @@
-<div style="margin-left: 10px;">
-  <h4 style="margin: 0; color: #007BFF;">Model Card Requirements</h4>
-  <p style="font-size: 0.875rem; color: #6c757d;">
-    Your model card must include: <strong>architecture</strong>,
-    <strong>training details</strong>, <strong>dataset information</strong>, intended use, limitations, and
-    <strong>performance metrics</strong>.
-  </p>
-  <a href="https://huggingface.co/docs/hub/model-cards" target="_blank" style="color: #007BFF; text-decoration: underline; font-family: monospace;">Model cards guide →</a>
-</div>
+<h4 style="margin: 0; color: #007BFF;">Model Card</h4>
+<p style="font-size: 0.875rem; color: #6c757d;">
+  Your model card must include: <strong>architecture</strong>,
+  <strong>training details</strong>, <strong>dataset information</strong>, intended use, limitations, and
+  <strong>performance metrics</strong>.
+</p>
+<a href="https://huggingface.co/docs/hub/model-cards" target="_blank" style="color: #007BFF; text-decoration: underline; font-family: monospace;">Model cards guide →</a>

assets/html/05_checklist.html

@@ -1,8 +1,6 @@
-<div style="margin-left: 10px;">
-  <h4 style="margin: 0; color: #007BFF;">Checklist</h4>
-  <p style="font-size: 0.875rem; color: #6c757d;">
-    Ensure your model is <strong>public</strong>, uses <strong>safetensors</strong> format,
-    has a <strong>license tag</strong>, and <strong>loads correctly</strong> with the provided code.
-  </p>
-  <a href="https://huggingface.co/docs/hub/repositories-getting-started" target="_blank" style="color: #007BFF; text-decoration: underline; font-family: monospace;">Sharing best practices →</a>
-</div>
+<h4 style="margin: 0; color: #007BFF;">Checklist</h4>
+<p style="font-size: 0.875rem; color: #6c757d;">
+  Ensure your model is <strong>public</strong>, uses <strong>safetensors</strong> format,
+  has a <strong>license tag</strong>, and <strong>loads correctly</strong> with the provided code.
+</p>
+<a href="https://huggingface.co/docs/hub/repositories-getting-started" target="_blank" style="color: #007BFF; text-decoration: underline; font-family: monospace;">Sharing best practices →</a>

assets/html/06_ready.html

@@ -0,0 +1,4 @@
+<h4 style="margin: 0; color: #007BFF;">Ready!</h4>
+<p style="font-size: 0.875rem; color: #6c757d;">
+    If you meet all these requirements, your model will be evaluated 🎉
+</p>

src/task_mappings.py

@@ -153,7 +153,7 @@ semantic_categories = {
 # Professional tasks are those that have economic interest for the industry.
 # Tasks like author profiling, sentiment analysis, machine-generated text detection, fake news detection, stance, discrimination, etc. are under this category.
 professional_mapping = {
-    "Fundamental NLP": [
+     "Fundamental NLP": [
         "iberbench/iberlef-adobo-lexical_borrowing_chunking-2021-spanish",
         "iberbench/general-eus_exams-question_answering-2024-basque",
         "iberbench/general-eus_exams-question_answering-2024-spanish",
@@ -172,10 +172,10 @@ professional_mapping = {
         "iberbench/general-belebele-reading_comprehension-2024-spanish",
         "iberbench/general-escola-linguistic_acceptability-2024-spanish",
         "iberbench/general-xnli-textual_entailment-2024-spanish",
-        "iberbench/general-xnli-textual_entailment-2024-galician",
+        "iberbench/general-xnli-textual_entailment-2024-galician",       
         "iberbench/general-galcola-linguistic_acceptability-2024-galician",
-        "iberbench/general-xstorycloze-question_answering-2024-galician",
-        "iberbench/general-belebele-reading_comprehension-2024-portuguese",,
+        "iberbench/general-xstorycloze-question_answering-2024-galician", 
+        "iberbench/general-belebele-reading_comprehension-2024-portuguese",
         "iberbench/general-xstorycloze-question_answering-2024-portuguese",
         "iberbench/general-xstorycloze-question_answering-2024-catalan",
         "iberbench/general-xnli-textual_entailment-2024-catalan",
@@ -185,8 +185,8 @@ professional_mapping = {
         "iberbench/general-copa-commonsense_reasoning-2024-catalan",
         "iberbench/general-catcola-linguistic_acceptability-2024-catalan",
         "iberbench/general-teca-textual_entailment-2021-catalan",
-    ],
-    "Professional NLP": [
+        ],
+     "Industry NLP": [
         "iberbench/iberlef-restmex-sentiment_analysis-2022-spanish-mexico",
         "iberbench/iberlef-restmex-sentiment_analysis-2021-spanish-mexico"
         "iberbench/general-parafraseja-paraphrase_detection-2022-catalan",
@@ -258,4 +258,4 @@ professional_mapping = {
         "iberbench/pan-author_profiling-age_detection-2015-spanish",
         "iberbench/general-hate_check-hate_speech_detection-2024-portuguese"
     ]
-}
+}