Add search bar/filtering; always show Model Size

app.py

@@ -1,6 +1,7 @@
-from functools import partial
+from functools import partial, reduce
 import json
 import os
+import re
 
 from datasets import load_dataset
 import gradio as gr
@@ -1098,7 +1099,7 @@ def add_rank(df):
     if len(cols_to_rank) == 1:
         df.sort_values(cols_to_rank[0], ascending=False, inplace=True)
     else:
-        df.insert(1, "Average", df[cols_to_rank].mean(axis=1, skipna=False))
+        df.insert(len(df.columns) - len(cols_to_rank), "Average", df[cols_to_rank].mean(axis=1, skipna=False))
         df.sort_values("Average", ascending=False, inplace=True)
     df.insert(0, "Rank", list(range(1, len(df) + 1)))
     df = df.round(2)
@@ -1106,7 +1107,7 @@ def add_rank(df):
     df.fillna("", inplace=True)
     return df
 
-def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_emb_dim=False, task_to_metric=TASK_TO_METRIC, rank=True):
+def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_emb_dim=True, task_to_metric=TASK_TO_METRIC, rank=True):
     api = HfApi()
     models = api.list_models(filter="mteb")
     # Initialize list to models that we cannot fetch metadata from
@@ -1169,6 +1170,8 @@ def get_mteb_data(tasks=["Clustering"], langs=[], datasets=[], fillna=True, add_
                 except:
                     pass
             df_list.append(out)
+        if len(df_list) >= 1:
+            break
     df = pd.DataFrame(df_list)
     # If there are any models that are the same, merge them
     # E.g. if out["Model"] has the same value in two places, merge & take whichever one is not NaN else just take the first one
@@ -1217,26 +1220,26 @@ def get_mteb_average():
 
     DATA_OVERALL = DATA_OVERALL.round(2)
 
-    DATA_CLASSIFICATION_EN = add_rank(DATA_OVERALL[["Model"] + TASK_LIST_CLASSIFICATION])
+    DATA_CLASSIFICATION_EN = add_rank(DATA_OVERALL[["Model", "Model Size (Million Parameters)"] + TASK_LIST_CLASSIFICATION])
     # Only keep rows with at least one score in addition to the "Model" & rank column
-    DATA_CLASSIFICATION_EN = DATA_CLASSIFICATION_EN[DATA_CLASSIFICATION_EN.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_CLASSIFICATION_EN = DATA_CLASSIFICATION_EN[DATA_CLASSIFICATION_EN.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_CLUSTERING = add_rank(DATA_OVERALL[["Model"] + TASK_LIST_CLUSTERING])
-    DATA_CLUSTERING = DATA_CLUSTERING[DATA_CLUSTERING.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_CLUSTERING = add_rank(DATA_OVERALL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_CLUSTERING])
+    DATA_CLUSTERING = DATA_CLUSTERING[DATA_CLUSTERING.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_PAIR_CLASSIFICATION = add_rank(DATA_OVERALL[["Model"] + TASK_LIST_PAIR_CLASSIFICATION])
-    DATA_PAIR_CLASSIFICATION = DATA_PAIR_CLASSIFICATION[DATA_PAIR_CLASSIFICATION.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_PAIR_CLASSIFICATION = add_rank(DATA_OVERALL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_PAIR_CLASSIFICATION])
+    DATA_PAIR_CLASSIFICATION = DATA_PAIR_CLASSIFICATION[DATA_PAIR_CLASSIFICATION.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_RERANKING = add_rank(DATA_OVERALL[["Model"] + TASK_LIST_RERANKING])
-    DATA_RERANKING = DATA_RERANKING[DATA_RERANKING.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_RERANKING = add_rank(DATA_OVERALL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_RERANKING])
+    DATA_RERANKING = DATA_RERANKING[DATA_RERANKING.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_RETRIEVAL = add_rank(DATA_OVERALL[["Model"] + TASK_LIST_RETRIEVAL])
-    DATA_RETRIEVAL = DATA_RETRIEVAL[DATA_RETRIEVAL.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_RETRIEVAL = add_rank(DATA_OVERALL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_RETRIEVAL])
+    DATA_RETRIEVAL = DATA_RETRIEVAL[DATA_RETRIEVAL.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_STS_EN = add_rank(DATA_OVERALL[["Model"] + TASK_LIST_STS])
-    DATA_STS_EN = DATA_STS_EN[DATA_STS_EN.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_STS_EN = add_rank(DATA_OVERALL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_STS])
+    DATA_STS_EN = DATA_STS_EN[DATA_STS_EN.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_SUMMARIZATION = add_rank(DATA_OVERALL[["Model"] + TASK_LIST_SUMMARIZATION])
+    DATA_SUMMARIZATION = add_rank(DATA_OVERALL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_SUMMARIZATION])
     DATA_SUMMARIZATION = DATA_SUMMARIZATION[DATA_SUMMARIZATION.iloc[:, 1:].ne("").any(axis=1)]
 
     # Fill NaN after averaging
@@ -1279,24 +1282,24 @@ def get_mteb_average_zh():
 
     DATA_OVERALL_ZH = DATA_OVERALL_ZH.round(2)
 
-    DATA_CLASSIFICATION_ZH = add_rank(DATA_OVERALL_ZH[["Model"] + TASK_LIST_CLASSIFICATION_ZH])
+    DATA_CLASSIFICATION_ZH = add_rank(DATA_OVERALL_ZH[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_CLASSIFICATION_ZH])
     # Only keep rows with at least one score in addition to the "Model" & rank column
-    DATA_CLASSIFICATION_ZH = DATA_CLASSIFICATION_ZH[DATA_CLASSIFICATION_ZH.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_CLASSIFICATION_ZH = DATA_CLASSIFICATION_ZH[DATA_CLASSIFICATION_ZH.iloc[:, 3:].ne("").any(axis=1)]
     
-    DATA_CLUSTERING_ZH = add_rank(DATA_OVERALL_ZH[["Model"] + TASK_LIST_CLUSTERING_ZH])
-    DATA_CLUSTERING_ZH = DATA_CLUSTERING_ZH[DATA_CLUSTERING_ZH.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_CLUSTERING_ZH = add_rank(DATA_OVERALL_ZH[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_CLUSTERING_ZH])
+    DATA_CLUSTERING_ZH = DATA_CLUSTERING_ZH[DATA_CLUSTERING_ZH.iloc[:, 3:].ne("").any(axis=1)]
     
-    DATA_PAIR_CLASSIFICATION_ZH = add_rank(DATA_OVERALL_ZH[["Model"] + TASK_LIST_PAIR_CLASSIFICATION_ZH])
-    DATA_PAIR_CLASSIFICATION_ZH = DATA_PAIR_CLASSIFICATION_ZH[DATA_PAIR_CLASSIFICATION_ZH.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_PAIR_CLASSIFICATION_ZH = add_rank(DATA_OVERALL_ZH[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_PAIR_CLASSIFICATION_ZH])
+    DATA_PAIR_CLASSIFICATION_ZH = DATA_PAIR_CLASSIFICATION_ZH[DATA_PAIR_CLASSIFICATION_ZH.iloc[:, 3:].ne("").any(axis=1)]
     
-    DATA_RERANKING_ZH = add_rank(DATA_OVERALL_ZH[["Model"] + TASK_LIST_RERANKING_ZH])
-    DATA_RERANKING_ZH = DATA_RERANKING_ZH[DATA_RERANKING_ZH.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_RERANKING_ZH = add_rank(DATA_OVERALL_ZH[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_RERANKING_ZH])
+    DATA_RERANKING_ZH = DATA_RERANKING_ZH[DATA_RERANKING_ZH.iloc[:, 3:].ne("").any(axis=1)]
     
-    DATA_RETRIEVAL_ZH = add_rank(DATA_OVERALL_ZH[["Model"] + TASK_LIST_RETRIEVAL_ZH])
-    DATA_RETRIEVAL_ZH = DATA_RETRIEVAL_ZH[DATA_RETRIEVAL_ZH.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_RETRIEVAL_ZH = add_rank(DATA_OVERALL_ZH[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_RETRIEVAL_ZH])
+    DATA_RETRIEVAL_ZH = DATA_RETRIEVAL_ZH[DATA_RETRIEVAL_ZH.iloc[:, 3:].ne("").any(axis=1)]
     
-    DATA_STS_ZH = add_rank(DATA_OVERALL_ZH[["Model"] + TASK_LIST_STS_ZH])
-    DATA_STS_ZH = DATA_STS_ZH[DATA_STS_ZH.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_STS_ZH = add_rank(DATA_OVERALL_ZH[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_STS_ZH])
+    DATA_STS_ZH = DATA_STS_ZH[DATA_STS_ZH.iloc[:, 3:].ne("").any(axis=1)]
 
     # Fill NaN after averaging
     DATA_OVERALL_ZH.fillna("", inplace=True)
@@ -1339,25 +1342,25 @@ def get_mteb_average_fr():
     DATA_OVERALL_FR.insert(0, "Rank", list(range(1, len(DATA_OVERALL_FR) + 1)))
     DATA_OVERALL_FR = DATA_OVERALL_FR.round(2)
 
-    DATA_CLASSIFICATION_FR = add_rank(DATA_OVERALL_FR[["Model"] + TASK_LIST_CLASSIFICATION_FR])
-    DATA_CLASSIFICATION_FR = DATA_CLASSIFICATION_FR[DATA_CLASSIFICATION_FR.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_CLASSIFICATION_FR = add_rank(DATA_OVERALL_FR[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_CLASSIFICATION_FR])
+    DATA_CLASSIFICATION_FR = DATA_CLASSIFICATION_FR[DATA_CLASSIFICATION_FR.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_CLUSTERING_FR = add_rank(DATA_OVERALL_FR[["Model"] + TASK_LIST_CLUSTERING_FR])
-    DATA_CLUSTERING_FR = DATA_CLUSTERING_FR[DATA_CLUSTERING_FR.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_CLUSTERING_FR = add_rank(DATA_OVERALL_FR[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_CLUSTERING_FR])
+    DATA_CLUSTERING_FR = DATA_CLUSTERING_FR[DATA_CLUSTERING_FR.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_PAIR_CLASSIFICATION_FR = add_rank(DATA_OVERALL_FR[["Model"] + TASK_LIST_PAIR_CLASSIFICATION_FR])
-    DATA_PAIR_CLASSIFICATION_FR = DATA_PAIR_CLASSIFICATION_FR[DATA_PAIR_CLASSIFICATION_FR.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_PAIR_CLASSIFICATION_FR = add_rank(DATA_OVERALL_FR[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_PAIR_CLASSIFICATION_FR])
+    DATA_PAIR_CLASSIFICATION_FR = DATA_PAIR_CLASSIFICATION_FR[DATA_PAIR_CLASSIFICATION_FR.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_RERANKING_FR = add_rank(DATA_OVERALL_FR[["Model"] + TASK_LIST_RERANKING_FR])
-    DATA_RERANKING_FR = DATA_RERANKING_FR[DATA_RERANKING_FR.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_RERANKING_FR = add_rank(DATA_OVERALL_FR[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_RERANKING_FR])
+    DATA_RERANKING_FR = DATA_RERANKING_FR[DATA_RERANKING_FR.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_RETRIEVAL_FR = add_rank(DATA_OVERALL_FR[["Model"] + TASK_LIST_RETRIEVAL_FR])
-    DATA_RETRIEVAL_FR = DATA_RETRIEVAL_FR[DATA_RETRIEVAL_FR.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_RETRIEVAL_FR = add_rank(DATA_OVERALL_FR[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_RETRIEVAL_FR])
+    DATA_RETRIEVAL_FR = DATA_RETRIEVAL_FR[DATA_RETRIEVAL_FR.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_STS_FR = add_rank(DATA_OVERALL_FR[["Model"] + TASK_LIST_STS_FR])
-    DATA_STS_FR = DATA_STS_FR[DATA_STS_FR.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_STS_FR = add_rank(DATA_OVERALL_FR[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_STS_FR])
+    DATA_STS_FR = DATA_STS_FR[DATA_STS_FR.iloc[:, 3:].ne("").any(axis=1)]
 
-    DATA_SUMMARIZATION_FR = add_rank(DATA_OVERALL_FR[["Model"] + TASK_LIST_SUMMARIZATION_FR])
+    DATA_SUMMARIZATION_FR = add_rank(DATA_OVERALL_FR[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_SUMMARIZATION_FR])
     DATA_SUMMARIZATION_FR = DATA_SUMMARIZATION_FR[DATA_SUMMARIZATION_FR.iloc[:, 1:].ne("").any(axis=1)]
 
     # Fill NaN after averaging
@@ -1398,21 +1401,21 @@ def get_mteb_average_pl():
 
     DATA_OVERALL_PL = DATA_OVERALL_PL.round(2)
 
-    DATA_CLASSIFICATION_PL = add_rank(DATA_OVERALL_PL[["Model"] + TASK_LIST_CLASSIFICATION_PL])
+    DATA_CLASSIFICATION_PL = add_rank(DATA_OVERALL_PL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_CLASSIFICATION_PL])
     # Only keep rows with at least one score in addition to the "Model" & rank column
-    DATA_CLASSIFICATION_PL = DATA_CLASSIFICATION_PL[DATA_CLASSIFICATION_PL.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_CLASSIFICATION_PL = DATA_CLASSIFICATION_PL[DATA_CLASSIFICATION_PL.iloc[:, 3:].ne("").any(axis=1)]
     
-    DATA_CLUSTERING_PL = add_rank(DATA_OVERALL_PL[["Model"] + TASK_LIST_CLUSTERING_PL])
-    DATA_CLUSTERING_PL = DATA_CLUSTERING_PL[DATA_CLUSTERING_PL.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_CLUSTERING_PL = add_rank(DATA_OVERALL_PL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_CLUSTERING_PL])
+    DATA_CLUSTERING_PL = DATA_CLUSTERING_PL[DATA_CLUSTERING_PL.iloc[:, 3:].ne("").any(axis=1)]
     
-    DATA_PAIR_CLASSIFICATION_PL = add_rank(DATA_OVERALL_PL[["Model"] + TASK_LIST_PAIR_CLASSIFICATION_PL])
-    DATA_PAIR_CLASSIFICATION_PL = DATA_PAIR_CLASSIFICATION_PL[DATA_PAIR_CLASSIFICATION_PL.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_PAIR_CLASSIFICATION_PL = add_rank(DATA_OVERALL_PL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_PAIR_CLASSIFICATION_PL])
+    DATA_PAIR_CLASSIFICATION_PL = DATA_PAIR_CLASSIFICATION_PL[DATA_PAIR_CLASSIFICATION_PL.iloc[:, 3:].ne("").any(axis=1)]
     
-    DATA_RETRIEVAL_PL = add_rank(DATA_OVERALL_PL[["Model"] + TASK_LIST_RETRIEVAL_PL])
-    DATA_RETRIEVAL_PL = DATA_RETRIEVAL_PL[DATA_RETRIEVAL_PL.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_RETRIEVAL_PL = add_rank(DATA_OVERALL_PL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_RETRIEVAL_PL])
+    DATA_RETRIEVAL_PL = DATA_RETRIEVAL_PL[DATA_RETRIEVAL_PL.iloc[:, 3:].ne("").any(axis=1)]
     
-    DATA_STS_PL = add_rank(DATA_OVERALL_PL[["Model"] + TASK_LIST_STS_PL])
-    DATA_STS_PL = DATA_STS_PL[DATA_STS_PL.iloc[:, 2:].ne("").any(axis=1)]
+    DATA_STS_PL = add_rank(DATA_OVERALL_PL[["Model", "Model Size (Million Parameters)"] +  TASK_LIST_STS_PL])
+    DATA_STS_PL = DATA_STS_PL[DATA_STS_PL.iloc[:, 3:].ne("").any(axis=1)]
 
     # Fill NaN after averaging
     DATA_OVERALL_PL.fillna("", inplace=True)
@@ -1426,14 +1429,14 @@ get_mteb_average()
 get_mteb_average_fr()
 get_mteb_average_pl()
 get_mteb_average_zh()
-DATA_BITEXT_MINING = get_mteb_data(["BitextMining"], [], TASK_LIST_BITEXT_MINING)
-DATA_BITEXT_MINING_DA = get_mteb_data(["BitextMining"], [], TASK_LIST_BITEXT_MINING_DA)
-DATA_CLASSIFICATION_DA = get_mteb_data(["Classification"], [], TASK_LIST_CLASSIFICATION_DA)
-DATA_CLASSIFICATION_NB = get_mteb_data(["Classification"], [], TASK_LIST_CLASSIFICATION_NB)
-DATA_CLASSIFICATION_SV = get_mteb_data(["Classification"], [], TASK_LIST_CLASSIFICATION_SV)
-DATA_CLASSIFICATION_OTHER = get_mteb_data(["Classification"], [], TASK_LIST_CLASSIFICATION_OTHER)
-DATA_CLUSTERING_DE = get_mteb_data(["Clustering"], [], TASK_LIST_CLUSTERING_DE)
-DATA_STS_OTHER = get_mteb_data(["STS"], [], TASK_LIST_STS_OTHER)
+DATA_BITEXT_MINING = get_mteb_data(["BitextMining"], [], TASK_LIST_BITEXT_MINING)[["Rank", "Model", "Model Size (Million Parameters)", "Average"] + TASK_LIST_BITEXT_MINING]
+DATA_BITEXT_MINING_DA = get_mteb_data(["BitextMining"], [], TASK_LIST_BITEXT_MINING_DA)[["Rank", "Model", "Model Size (Million Parameters)"] + TASK_LIST_BITEXT_MINING_DA]
+DATA_CLASSIFICATION_DA = get_mteb_data(["Classification"], [], TASK_LIST_CLASSIFICATION_DA)[["Rank", "Model", "Model Size (Million Parameters)", "Average"] + TASK_LIST_CLASSIFICATION_DA]
+DATA_CLASSIFICATION_NB = get_mteb_data(["Classification"], [], TASK_LIST_CLASSIFICATION_NB)[["Rank", "Model", "Model Size (Million Parameters)", "Average"] + TASK_LIST_CLASSIFICATION_NB]
+DATA_CLASSIFICATION_SV = get_mteb_data(["Classification"], [], TASK_LIST_CLASSIFICATION_SV)[["Rank", "Model", "Model Size (Million Parameters)", "Average"] + TASK_LIST_CLASSIFICATION_SV]
+DATA_CLASSIFICATION_OTHER = get_mteb_data(["Classification"], [], TASK_LIST_CLASSIFICATION_OTHER)[["Rank", "Model", "Model Size (Million Parameters)", "Average"] + TASK_LIST_CLASSIFICATION_OTHER]
+DATA_CLUSTERING_DE = get_mteb_data(["Clustering"], [], TASK_LIST_CLUSTERING_DE)[["Rank", "Model", "Model Size (Million Parameters)", "Average"] + TASK_LIST_CLUSTERING_DE]
+DATA_STS_OTHER = get_mteb_data(["STS"], [], TASK_LIST_STS_OTHER)[["Rank", "Model", "Model Size (Million Parameters)", "Average"] + TASK_LIST_STS_OTHER]
 
 # Exact, add all non-nan integer values for every dataset
 NUM_SCORES = 0
@@ -1476,7 +1479,7 @@ for d in [
     DATA_SUMMARIZATION_FR,
 ]:
     # NUM_SCORES += d.iloc[:, 1:].apply(lambda x: sum([1 for y in x if isinstance(y, float) and not np.isnan(y)]), axis=1).sum()
-    cols_to_ignore = 3 if "Average" in d.columns else 2
+    cols_to_ignore = 4 if "Average" in d.columns else 3
     # Count number of scores including only non-nan floats & excluding the rank column
     NUM_SCORES += d.iloc[:, cols_to_ignore:].notna().sum().sum()
     # Exclude rank & model name column (first two); Do not count different language versions as different datasets
@@ -1491,6 +1494,7 @@ NUM_MODELS = len(set(MODELS))
 # 1. Force headers to wrap
 # 2. Force model column (maximum) width
 # 3. Prevent model column from overflowing, scroll instead
+# 4. Prevent checkbox groups from taking up too much space
 css = """
 table > thead {
     white-space: normal
@@ -1503,6 +1507,10 @@ table {
 table > tbody > tr > td:nth-child(2) > div {
     overflow-x: auto
 }
+
+.filter-checkbox-group {
+    max-width: max-content;
+}
 """
 
 """
@@ -1822,6 +1830,7 @@ data = {
 }
 
 dataframes = []
+full_dataframes = []
 tabs = []
 
 # The following JavaScript function updates the URL parameters based on the selected task and language
@@ -1854,6 +1863,57 @@ def update_url_language(event: gr.SelectData, current_task_language: dict, langu
     language_per_task[current_task_language["task"]] = event.target.id
     return current_task_language, language_per_task
 
+NUMERIC_INTERVALS = {
+    "<100M": pd.Interval(0, 100, closed="right"),
+    ">100M, <500M": pd.Interval(100, 500, closed="right"),
+    ">500M, <1B": pd.Interval(500, 1000, closed="right"),
+    ">1B": pd.Interval(1000, 1_000_000, closed="right"),
+}
+
+MODEL_TYPES = [
+    "Open",
+    "API",
+]
+
+def filter_data(search_query, model_types, model_sizes, *full_dataframes):
+    output_dataframes = []
+    for df in full_dataframes:
+        # df = pd.DataFrame(data=dataframe.value["data"], columns=dataframe.value["headers"])
+
+        # Apply the search query
+        if search_query:
+            names = df["Model"].map(lambda x: re.match("<a .+?>(.+)</a>", x).group(1))
+            masks = []
+            for query in search_query.split(";"):
+                masks.append(names.str.contains(query))
+            df = df[reduce(lambda a, b: a | b, masks)]
+
+        # Apply the model type filtering
+        if model_types != MODEL_TYPES:
+            masks = []
+            for model_type in model_types:
+                if model_type == "Open":
+                    masks.append(df["Model Size (Million Parameters)"] != "")
+                elif model_type == "API":
+                    masks.append(df["Model Size (Million Parameters)"] == "")
+            df = df[reduce(lambda a, b: a | b, masks)]
+
+        # Apply the model size filtering
+        if model_sizes != ["?", *NUMERIC_INTERVALS.keys()]:
+            masks = []
+            # Handle the ? only
+            if "?" in model_sizes:
+                masks.append(df["Model Size (Million Parameters)"] == "")
+                model_sizes.remove("?")
+            # Handle the numeric intervals only
+            numeric_interval = pd.IntervalIndex(sorted([NUMERIC_INTERVALS[model_size] for model_size in model_sizes]))
+            sizes = df["Model Size (Million Parameters)"].replace('', 0)
+            masks.append(sizes.apply(lambda size: any(numeric_interval.contains(size))))
+            df = df[reduce(lambda a, b: a | b, masks)]
+
+        output_dataframes.append(df)
+    return output_dataframes
+
 with gr.Blocks(css=css) as block:
 
     # Store the current task and language for updating the URL. This is a bit hacky, but it works
@@ -1865,6 +1925,26 @@ with gr.Blocks(css=css) as block:
     Massive Text Embedding Benchmark (MTEB) Leaderboard. To submit, refer to the <a href="https://github.com/embeddings-benchmark/mteb#leaderboard" target="_blank" style="text-decoration: underline">MTEB GitHub repository</a> 🤗 Refer to the [MTEB paper](https://arxiv.org/abs/2210.07316) for details on metrics, tasks and models.
     """)
 
+    with gr.Row():
+        search_bar = gr.Textbox(
+            label="Search Bar",
+            placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press enter...",
+        )
+        filter_model_type = gr.CheckboxGroup(
+            label="Model types",
+            choices=MODEL_TYPES,
+            value=MODEL_TYPES,
+            interactive=True,
+            elem_classes=["filter-checkbox-group"]
+        )
+        filter_model_sizes = gr.CheckboxGroup(
+            label="Model sizes (in number of parameters)",
+            choices=["?"] + list(NUMERIC_INTERVALS.keys()),
+            value=["?"] + list(NUMERIC_INTERVALS.keys()),
+            interactive=True,
+            elem_classes=["filter-checkbox-group"]
+        )
+
     with gr.Tabs() as outer_tabs:
         # Store the tabs for updating them on load based on URL parameters
         tabs.append(outer_tabs)
@@ -1901,9 +1981,12 @@ with gr.Blocks(css=css) as block:
 
                             with gr.Row():
                                 datatype = ["number", "markdown"] + ["number"] * len(item["data"])
-                                dataframe = gr.Dataframe(item["data"], datatype=datatype, type="pandas", height=600)
+                                dataframe = gr.Dataframe(item["data"], datatype=datatype, type="pandas", height=500)
                                 dataframes.append(dataframe)
 
+                                full_dataframe = gr.Dataframe(item["data"], datatype=datatype, type="pandas", visible=False)
+                                full_dataframes.append(full_dataframe)
+
                             with gr.Row():
                                 refresh_button = gr.Button("Refresh")
                                 refresh_button.click(item["refresh"], inputs=None, outputs=dataframe)
@@ -1950,6 +2033,10 @@ with gr.Blocks(css=css) as block:
 
     block.load(set_tabs_on_load, inputs=[], outputs=tabs + [current_task_language, language_per_task])
 
+    search_bar.submit(filter_data, inputs=[search_bar, filter_model_type, filter_model_sizes] + full_dataframes, outputs=dataframes)
+    filter_model_type.change(filter_data, inputs=[search_bar, filter_model_type, filter_model_sizes] + full_dataframes, outputs=dataframes)
+    filter_model_sizes.change(filter_data, inputs=[search_bar, filter_model_type, filter_model_sizes] + full_dataframes, outputs=dataframes)
+
 block.queue(max_size=10)
 block.launch()