remove Trust & Safety tab

app.py

@@ -3,14 +3,13 @@ import pandas as pd
 
 from src.about import CITATION_BUTTON_LABEL, CITATION_BUTTON_TEXT, INTRODUCTION_TEXT, LLM_BENCHMARKS_TEXT, TITLE
 from src.display.css_html_js import custom_css
-from src.display.utils import COLS, TS_COLS, TS_TYPES, TYPES, AutoEvalColumn, TSEvalColumn, fields
+from src.display.utils import COLS, TS_COLS, TYPES, AutoEvalColumn, fields
 from src.envs import CRM_RESULTS_PATH
 from src.populate import get_leaderboard_df_crm
 
-original_df, ts_df = get_leaderboard_df_crm(CRM_RESULTS_PATH, COLS, TS_COLS)
+original_df = get_leaderboard_df_crm(CRM_RESULTS_PATH, COLS, TS_COLS)
 
 leaderboard_df = original_df.copy()
-leaderboard_ts_df = ts_df.copy()
 # leaderboard_df = leaderboard_df.style.format({"accuracy_metric_average": "{0:.2f}"})
 
 
@@ -39,18 +38,6 @@ def update_table(
     return df.style.map(highlight_cost_band_low, props="background-color: #b3d5a4")
 
 
-def update_ts_table(
-    hidden_df: pd.DataFrame,
-    columns: list,
-    llm_query: list,
-    llm_provider_query: list,
-):
-    filtered_df = filter_llm_func(hidden_df, llm_query)
-    filtered_df = filter_llm_provider_func(filtered_df, llm_provider_query)
-    df = select_columns_ts_table(filtered_df, columns)
-    return df
-
-
 # def highlight_cols(x):
 #     df = x.copy()
 #     df.loc[:, :] = "color: black"
@@ -90,21 +77,6 @@ def init_leaderboard_df(
     )
 
 
-def init_leaderboard_ts_df(
-    leaderboard_df: pd.DataFrame,
-    columns: list,
-    llm_query: list,
-    llm_provider_query: list,
-):
-
-    return update_ts_table(
-        leaderboard_df,
-        columns,
-        llm_query,
-        llm_provider_query,
-    )
-
-
 def filter_accuracy_method_func(df: pd.DataFrame, accuracy_method_query: str) -> pd.DataFrame:
     return df[df["Accuracy Method"] == accuracy_method_query]
 
@@ -139,6 +111,10 @@ def filter_llm_provider_func(df: pd.DataFrame, llm_provider_query: list) -> pd.D
     return df[df["LLM Provider"].isin(llm_provider_query)]
 
 
+def filter_metric_area_func(df: pd.DataFrame, metric_area_query: list) -> pd.DataFrame:
+    return df[df["Metric Area"].isin(metric_area_query)]
+
+
 def select_columns(df: pd.DataFrame, columns: list) -> pd.DataFrame:
     always_here_cols = [
         AutoEvalColumn.model.name,
@@ -148,14 +124,6 @@ def select_columns(df: pd.DataFrame, columns: list) -> pd.DataFrame:
     return filtered_df
 
 
-def select_columns_ts_table(df: pd.DataFrame, columns: list) -> pd.DataFrame:
-    always_here_cols = [
-        TSEvalColumn.model.name,
-    ]
-    filtered_df = df[always_here_cols + [c for c in TS_COLS if c in df.columns and c in columns]]
-    return filtered_df
-
-
 demo = gr.Blocks(css=custom_css)
 with demo:
     gr.HTML(TITLE)
@@ -164,34 +132,17 @@ with demo:
     with gr.Tabs(elem_classes="tab-buttons") as tabs:
         with gr.TabItem("🏅 Leaderboard", elem_id="llm-benchmark-tab-table", id=0):
             with gr.Row():
-                with gr.Column():
-                    # with gr.Row():
-                    #     search_bar = gr.Textbox(
-                    #         placeholder=" 🔍 Search for your model (separate multiple queries with `;`) and press ENTER...",
-                    #         show_label=False,
-                    #         elem_id="search-bar",
-                    #     )
-                    with gr.Row():
-                        shown_columns = gr.CheckboxGroup(
-                            choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden],
-                            value=[
-                                c.name
-                                for c in fields(AutoEvalColumn)
-                                if c.displayed_by_default and not c.hidden and not c.never_hidden
-                            ],
-                            label="Select columns to show",
-                            elem_id="column-select",
-                            interactive=True,
-                        )
-                # with gr.Column(min_width=320):
-                #     # with gr.Box(elem_id="box-filter"):
-                #     filter_columns_type = gr.CheckboxGroup(
-                #         label="Model types",
-                #         choices=[t.to_str() for t in ModelType],
-                #         value=[t.to_str() for t in ModelType],
-                #         interactive=True,
-                #         elem_id="filter-columns-type",
-                #     )
+                shown_columns = gr.CheckboxGroup(
+                    choices=[c.name for c in fields(AutoEvalColumn) if not c.hidden and not c.never_hidden],
+                    value=[
+                        c.name
+                        for c in fields(AutoEvalColumn)
+                        if c.displayed_by_default and not c.hidden and not c.never_hidden
+                    ],
+                    label="Select columns to show",
+                    elem_id="column-select",
+                    interactive=True,
+                )
             with gr.Row():
                 with gr.Column():
                     filter_llm = gr.CheckboxGroup(
@@ -202,13 +153,22 @@ with demo:
                         interactive=True,
                     )
                 with gr.Column():
-                    filter_llm_provider = gr.CheckboxGroup(
-                        choices=list(original_df["LLM Provider"].unique()),
-                        value=list(original_df["LLM Provider"].unique()),
-                        label="LLM Provider",
-                        info="",
-                        interactive=True,
-                    )
+                    with gr.Row():
+                        filter_llm_provider = gr.CheckboxGroup(
+                            choices=list(original_df["LLM Provider"].unique()),
+                            value=list(original_df["LLM Provider"].unique()),
+                            label="LLM Provider",
+                            info="",
+                            interactive=True,
+                        )
+                    with gr.Row():
+                        filter_metric_area = gr.CheckboxGroup(
+                            choices=["Accuracy", "Speed (Latency)", "Trust & Safety", "Cost"],
+                            value=["Accuracy", "Speed (Latency)", "Trust & Safety", "Cost"],
+                            label="Metric Area",
+                            info="",
+                            interactive=True,
+                        )
             with gr.Row():
                 filter_use_case = gr.CheckboxGroup(
                     choices=list(original_df["Use Case Name"].unique()),
@@ -244,14 +204,6 @@ with demo:
                 #         multiselect=True,
                 #         interactive=True,
                 #     )
-                # with gr.Column():
-                #     filter_metric_area = gr.CheckboxGroup(
-                #         choices=["Accuracy", "Speed (Latency)", "Trust & Safety", "Cost"],
-                #         value=["Accuracy", "Speed (Latency)", "Trust & Safety", "Cost"],
-                #         label="Metric Area",
-                #         info="",
-                #         interactive=True,
-                #     )
                 with gr.Column():
                     filter_accuracy_method = gr.Radio(
                         choices=["Manual", "Auto"],
@@ -267,22 +219,6 @@ with demo:
                         info="Range: 0.0 to 4.0",
                         interactive=True,
                     )
-                # with gr.Column():
-                #     filter_llm = gr.CheckboxGroup(
-                #         choices=list(original_df["Model Name"].unique()),
-                #         value=list(leaderboard_df["Model Name"].unique()),
-                #         label="Model Name",
-                #         info="",
-                #         interactive=True,
-                #     )
-                # with gr.Column():
-                #     filter_llm_provider = gr.CheckboxGroup(
-                #         choices=list(original_df["LLM Provider"].unique()),
-                #         value=list(leaderboard_df["LLM Provider"].unique()),
-                #         label="LLM Provider",
-                #         info="",
-                #         interactive=True,
-                #     )
 
             leaderboard_table = gr.components.Dataframe(
                 # value=leaderboard_df[[c.name for c in fields(AutoEvalColumn) if c.never_hidden] + shown_columns.value],
@@ -311,19 +247,6 @@ with demo:
                 datatype=TYPES,
                 visible=False,
             )
-            # search_bar.submit(
-            #     update_table,
-            #     [
-            #         hidden_leaderboard_table_for_search,
-            #         shown_columns,
-            #         filter_columns_type,
-            #         filter_columns_precision,
-            #         filter_columns_size,
-            #         deleted_models_visibility,
-            #         search_bar,
-            #     ],
-            #     leaderboard_table,
-            # )
             for selector in [
                 shown_columns,
                 filter_llm,
@@ -333,10 +256,6 @@ with demo:
                 filter_use_case_area,
                 filter_use_case,
                 filter_use_case_type,
-                # filter_columns_type,
-                # filter_columns_precision,
-                # filter_columns_size,
-                # deleted_models_visibility,
             ]:
                 selector.change(
                     update_table,
@@ -350,81 +269,6 @@ with demo:
                         filter_use_case_area,
                         filter_use_case,
                         filter_use_case_type,
-                        # filter_columns_type,
-                        # filter_columns_precision,
-                        # filter_columns_size,
-                        # deleted_models_visibility,
-                        # search_bar,
-                    ],
-                    leaderboard_table,
-                    queue=True,
-                )
-        with gr.TabItem("🏅 Trust & Safety", elem_id="llm-benchmark-tab-table", id=2):
-            with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        shown_columns = gr.CheckboxGroup(
-                            choices=[c.name for c in fields(TSEvalColumn) if not c.hidden and not c.never_hidden],
-                            value=[
-                                c.name
-                                for c in fields(TSEvalColumn)
-                                if c.displayed_by_default and not c.hidden and not c.never_hidden
-                            ],
-                            label="Select columns to show",
-                            elem_id="column-select",
-                            interactive=True,
-                        )
-            with gr.Row():
-                with gr.Column():
-                    filter_llm = gr.CheckboxGroup(
-                        choices=list(ts_df["Model Name"].unique()),
-                        value=list(ts_df["Model Name"].unique()),
-                        label="Model Name",
-                        info="",
-                        interactive=True,
-                    )
-                with gr.Column():
-                    filter_llm_provider = gr.CheckboxGroup(
-                        choices=list(ts_df["LLM Provider"].unique()),
-                        value=list(ts_df["LLM Provider"].unique()),
-                        label="LLM Provider",
-                        info="",
-                        interactive=True,
-                    )
-
-            leaderboard_table = gr.components.Dataframe(
-                value=init_leaderboard_ts_df(
-                    leaderboard_ts_df,
-                    shown_columns.value,
-                    filter_llm.value,
-                    filter_llm_provider.value,
-                ),
-                headers=[c.name for c in fields(TSEvalColumn) if c.never_hidden] + shown_columns.value,
-                datatype=TS_TYPES,
-                elem_id="leaderboard-table",
-                interactive=False,
-                visible=True,
-            )
-
-            hidden_leaderboard_table_for_search = gr.components.Dataframe(
-                value=ts_df[TS_COLS],
-                headers=TS_COLS,
-                datatype=TS_TYPES,
-                visible=False,
-            )
-
-            for selector in [
-                shown_columns,
-                filter_llm,
-                filter_llm_provider,
-            ]:
-                selector.change(
-                    update_ts_table,
-                    [
-                        hidden_leaderboard_table_for_search,
-                        shown_columns,
-                        filter_llm,
-                        filter_llm_provider,
                     ],
                     leaderboard_table,
                     queue=True,

src/display/utils.py

@@ -26,26 +26,26 @@ auto_eval_column_dict.append(
     ["model", ColumnContent, ColumnContent("Model Name", "markdown", True, never_hidden=True)]
 )
 auto_eval_column_dict.append(["model_provider", ColumnContent, ColumnContent("LLM Provider", "markdown", True)])
-auto_eval_column_dict.append(["use_case_name", ColumnContent, ColumnContent("Use Case Name", "markdown", False)])
+auto_eval_column_dict.append(["use_case_name", ColumnContent, ColumnContent("Use Case Name", "markdown", True)])
 auto_eval_column_dict.append(["use_case_type", ColumnContent, ColumnContent("Use Case Type", "markdown", False)])
 auto_eval_column_dict.append(["accuracy_method", ColumnContent, ColumnContent("Accuracy Method", "markdown", False)])
 # Accuracy metrics
-auto_eval_column_dict.append(["accuracy_metric_average", ColumnContent, ColumnContent("Accuracy", "markdown", False)])
+auto_eval_column_dict.append(["accuracy_metric_average", ColumnContent, ColumnContent("Accuracy", "markdown", True)])
 auto_eval_column_dict.append(
     [
         "accuracy_metric_instruction_following",
         ColumnContent,
-        ColumnContent("Instruction Following", "markdown", False),
+        ColumnContent("Instruction Following", "markdown", True),
     ]
 )
 auto_eval_column_dict.append(
-    ["accuracy_metric_completeness", ColumnContent, ColumnContent("Completeness", "markdown", False)]
+    ["accuracy_metric_completeness", ColumnContent, ColumnContent("Completeness", "markdown", True)]
 )
 auto_eval_column_dict.append(
-    ["accuracy_metric_conciseness", ColumnContent, ColumnContent("Conciseness", "markdown", False)]
+    ["accuracy_metric_conciseness", ColumnContent, ColumnContent("Conciseness", "markdown", True)]
 )
 auto_eval_column_dict.append(
-    ["accuracy_metric_factuality", ColumnContent, ColumnContent("Factuality", "markdown", False)]
+    ["accuracy_metric_factuality", ColumnContent, ColumnContent("Factuality", "markdown", True)]
 )
 # Speed (Latency) & Cost metrics
 auto_eval_column_dict.append(["latency", ColumnContent, ColumnContent("Response Time (Sec)", "markdown", True)])

src/populate.py

@@ -67,4 +67,4 @@ def get_leaderboard_df_crm(
         by=[AutoEvalColumn.accuracy_metric_average.name], ascending=False
     )
     leaderboard_accuracy_df = leaderboard_accuracy_df[accuracy_cols].round(decimals=2)
-    return leaderboard_accuracy_df, leaderboard_ts_df
+    return leaderboard_accuracy_df