[Update]Change table

app.py

@@ -33,6 +33,20 @@ from PIL import Image
 from dummydatagen import dummy_data_for_plot, create_metric_plot_obj_1, dummydf
 import copy
 
+def load_data(data_path):
+    columns = ['Unlearned Methods', 'Source', 'Diffusion Models', 'Pre-ASR', 'Post-ASR','FID']
+    columns_sorted = ['Unlearned Methods', 'Source', 'Diffusion Models', 'Pre-ASR', 'Post-ASR','FID']
+    
+    df = pd.read_csv(data_path, usecols=columns).dropna()
+    df['Post-ASR'] = df['Post-ASR'].round(0)
+
+    # rank according to the Score column
+    df = df.sort_values(by='Score', ascending=False)
+    # reorder the columns
+    df = df[columns_sorted]
+
+
+    return df
 
 def restart_space():
     API.restart_space(repo_id=REPO_ID)
@@ -61,57 +75,62 @@ def restart_space():
 #     running_eval_queue_df,
 #     pending_eval_queue_df,
 # ) = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)
+csv_path='./assets/object_parachute.csv'
+df_results = load_data(csv_path)
+methods = list(set(df_results['Unlearned Methods']))
+all_columns = ['Unlearned Methods', 'Source', 'Diffusion Models', 'Pre-ASR', 'Post-ASR','FID']
+show_columns = ['Unlearned Methods', 'Source', 'Diffusion Models', 'Pre-ASR', 'Post-ASR','FID']
+TYPES = ['str', 'markdown', 'str', 'number', 'number', 'number']
 
-raw_data = dummydf()
-methods = list(set(raw_data['Unlearned Methods']))
-metrics = ["Pre-ASR","Post-ASR", "FID"]
+df_results_init = df_results.copy()[show_columns]
 
 def update_table(
     hidden_df: pd.DataFrame,
-    columns_1: list,
-    columns_2: list,
-    columns_3: list,
-    model1: list,
+    # columns: list,
+    #type_query: list,
+    open_query: list,
+    # precision_query: str,
+    # size_query: list,
+    # show_deleted: bool,
+    query: str,
 ):
-
-    filtered_df = select_columns(hidden_df, columns_1, columns_2, columns_3)
-
-    filtered_df = filter_model1(filtered_df, model1)
-
-    return filtered_df
-
-
-def select_columns(df: pd.DataFrame, columns_1: list, columns_2: list,  columns_3: list) -> pd.DataFrame:
-    always_here_cols = ["Unlearned Methods"]
+    # filtered_df = filter_models(hidden_df, type_query, size_query, precision_query, show_deleted)
+    # filtered_df = filter_queries(query, filtered_df)
+    # df = select_columns(filtered_df, columns)
+    filtered_df = hidden_df.copy()
     
-    # We use COLS to maintain sorting
-    all_columns = metrics
-
-    if (len(columns_1)+len(columns_2) + len(columns_3)) == 0:
-        filtered_df = df[
-            always_here_cols +
-            [c for c in all_columns if c in df.columns]
-        ]
-
-    else:
-        filtered_df = df[
-            always_here_cols +
-            [c for c in all_columns if c in df.columns and (c in columns_1 or c in columns_2 or c in columns_3 ) ]
-        ]
+    filtered_df = filtered_df[filtered_df['Models'].isin(open_query)]
+    # map_open = {'open': 'Yes', 'closed': 'No'}
+    # filtered_df = filtered_df[filtered_df['Open?'].isin([map_open[o] for o in open_query])]
+
+    filtered_df = filter_queries(query, filtered_df)
+    # filtered_df = filtered_df[[map_columns[k] for k in columns]]
+    # deduplication
+    # df = df.drop_duplicates(subset=["Model"])
+    df = filtered_df.drop_duplicates()
+    df = df[show_columns]
+    return df
+
+
+def search_table(df: pd.DataFrame, query: str) -> pd.DataFrame:
+    return df[(df['Model'].str.contains(query, case=False))]
+
+
+def filter_queries(query: str, filtered_df: pd.DataFrame) -> pd.DataFrame:
+    final_df = []
+    if query != "":
+        queries = [q.strip() for q in query.split(";")]
+        for _q in queries:
+            _q = _q.strip()
+            if _q != "":
+                temp_filtered_df = search_table(filtered_df, _q)
+                if len(temp_filtered_df) > 0:
+                    final_df.append(temp_filtered_df)
+        if len(final_df) > 0:
+            filtered_df = pd.concat(final_df)
 
     return filtered_df
 
-
-def filter_model1(df: pd.DataFrame, model_query: list) -> pd.DataFrame:
-    # Show all models
-    if len(model_query) == 0:
-        return df
-    
-    filtered_df = df
-    filtered_df = filtered_df[filtered_df["Method"].isin(model_query)]
-    return filtered_df
-
-
 demo = gr.Blocks(css=custom_css)
 with demo:
     gr.HTML(TITLE)
@@ -135,13 +154,14 @@ with demo:
                         interactive=True,
                         elem_id="column-select",
                     )
-                    # with gr.Row():
-                    #     method_column = gr.CheckboxGroup(
-                    #     label="Unlearning Methods",
-                    #     choices=["ESD","FMN", "AC", "UCE", "SLD"],
-                    #     interactive=True,
-                    #     elem_id="column-select",
-                    # )
+                    with gr.Row():
+                        open_query = gr.CheckboxGroup(
+                        label="Model",
+                        choices=["SD V1.4","SD V1.5", "SD V2.0"],
+                        values =["SD V1.4","SD V1.5", "SD V2.0"]
+                        interactive=True,
+                        elem_id="column-select",
+                    )
                 # with gr.Column(min_width=320):
                     # with gr.Row():
                     #     shown_columns_1 = gr.CheckboxGroup(
@@ -171,30 +191,58 @@ with demo:
                     #         interactive=True,)
             gr.Markdown("### Unlearned Concepts Parachute")
             leaderboard_table = gr.components.Dataframe(
-                value= raw_data,
-                elem_id="leaderboard-table",
-                interactive=False,
+                value = df_results,
+                datatype = TYPES,
+                elem_id = "leaderboard-table",
+                interactive = False,
                 visible=True,
+                # column_widths=["20%", "6%", "8%", "6%", "8%", "8%", "6%", "6%", "6%", "6%", "6%"],
             )
 
-            game_bench_df_for_search = gr.components.Dataframe(
-                value= raw_data,
-                elem_id="leaderboard-table",
+            # gr.Markdown("The \"Cost\" column is calculated as USD / Million tokens of output.")
+
+            hidden_leaderboard_table_for_search = gr.components.Dataframe(
+                value=df_results_init,
+                # elem_id="leaderboard-table",
                 interactive=False,
                 visible=False,
             )
 
+            search_bar.submit(
+                update_table,
+                [   
+                    # df_avg,
+                    hidden_leaderboard_table_for_search,
+                    # shown_columns,
+                    #type_query,
+                    open_query,
+                    # filter_columns_type,
+                    # filter_columns_precision,
+                    # filter_columns_size,
+                    # deleted_models_visibility,
+                    search_bar,
+                ],
+                leaderboard_table,
+            )
 
-            for selector in [model1_column]:
+            #for selector in [type_query, open_query]:
+            for selector in [open_query]:
                 selector.change(
                     update_table,
                     [   
-                        game_bench_df_for_search,
-                        model1_column, 
+                        # df_avg,
+                        hidden_leaderboard_table_for_search,
+                        # shown_columns,
+                        #type_query,
+                        open_query,
+                        # filter_columns_type,
+                        # filter_columns_precision,
+                        # filter_columns_size,
+                        # deleted_models_visibility,
+                        search_bar,
                     ],
                     leaderboard_table,
-                    queue=True,
-                )    
+                )
     #                 with gr.Row():
     #                     shown_columns = gr.CheckboxGroup(
     #                         choices=[