Add fuzzywuzzy dependency and update model submission functions in utils.py

app.py

@@ -1,12 +1,11 @@
 import gradio as gr
 from utils import submit_gradio_module, load_retrieval_results
-
+from fuzzywuzzy import fuzz
 
 HEADER = """<div style="text-align: center; margin-bottom: 20px;">
     <h1>The Arabic RAG Leaderboard</h1>
     <p style="font-size: 14px; color: #888;">The only leaderboard you will require for your RAG needs 🏆</p>
 </div>
-
 """
 
 ABOUT_SECTION = """
@@ -44,6 +43,28 @@ CITATION_BUTTON_TEXT = """
 df = load_retrieval_results()
 print(df)
 
+def search_leaderboard(model_name):
+    if not model_name:
+        return df
+    
+    threshold = 95  # You can adjust this value to make the search more or less strict
+
+    def calculate_similarity(row):
+        similarity = fuzz.partial_ratio(model_name.lower(), row['model'].lower())
+        return similarity if similarity >= threshold else 0
+
+    # Add a new column for similarity scores
+    df['similarity'] = df.apply(calculate_similarity, axis=1)
+
+    # Filter and sort the dataframe
+    filtered_df = df[df['similarity'] > 0].sort_values('similarity', ascending=False)
+
+    # Remove the similarity column before returning
+    filtered_df = filtered_df.drop('similarity', axis=1)
+
+    return filtered_df
+
+
 def main():
 
     with gr.Blocks() as demo:
@@ -60,254 +81,46 @@ def main():
                                 interactive=True
                             )
 
-                        with gr.Row():
-                            column_selector_tasks = gr.CheckboxGroup(
-                                choices=[],
-                                value=['Rank', 'Model Name'],
-                                label="Select columns to display",
-                            )
-                        
-                        with gr.Row():
-                            license_filter_retrieval = gr.CheckboxGroup(
-                                choices=[],
-                                value=[],  # Default all selected
-                                label="Filter by License",
-                            )
-                            precision_filter_retrieval = gr.CheckboxGroup(
-                                choices=[],
-                                value=[],  # Default all selected
-                                label="Filter by Precision",
-                            )
-                        
                         retrieval_leaderboard = gr.Dataframe(
                             df,
                             interactive=False
                         )
                         
-                        # def filter_df_3c3h(search_query, selected_cols, precision_filters, license_filters):
-                        #     filtered_df = df_3c3h.copy()
-                            
-                        #     # Ensure min_size <= max_size
-                        #     if min_size > max_size:
-                        #         min_size, max_size = max_size, min_size
-                            
-                        #     # Apply search filter
-                        #     if search_query:
-                        #         filtered_df = filtered_df[filtered_df['Model Name'].str.contains(search_query, case=False, na=False)]
-                            
-                        #     # Apply Precision filter
-                        #     if precision_filters:
-                        #         include_missing = 'Missing' in precision_filters
-                        #         selected_precisions = [p for p in precision_filters if p != 'Missing']
-                        #         if include_missing:
-                        #             filtered_df = filtered_df[
-                        #                 (filtered_df['Precision'].isin(selected_precisions)) |
-                        #                 (filtered_df['Precision'] == 'UNK') |
-                        #                 (filtered_df['Precision'].isna())
-                        #             ]
-                        #         else:
-                        #             filtered_df = filtered_df[filtered_df['Precision'].isin(selected_precisions)]
-                            
-                        #     # Apply License filter
-                        #     if license_filters:
-                        #         include_missing = 'Missing' in license_filters
-                        #         selected_licenses = [l for l in license_filters if l != 'Missing']
-                        #         if include_missing:
-                        #             filtered_df = filtered_df[
-                        #                 (filtered_df['License'].isin(selected_licenses)) |
-                        #                 (filtered_df['License'] == 'UNK') |
-                        #                 (filtered_df['License'].isna())
-                        #             ]
-                        #         else:
-                        #             filtered_df = filtered_df[filtered_df['License'].isin(selected_licenses)]
-                            
-                        #     # Apply Model Size filter
-                        #     filtered_df = filtered_df[
-                        #         (filtered_df['Model Size Filter'] >= min_size) &
-                        #         (filtered_df['Model Size Filter'] <= max_size)
-                        #     ]
-                            
-                        #     # Remove existing 'Rank' column if present
-                        #     if 'Rank' in filtered_df.columns:
-                        #         filtered_df = filtered_df.drop(columns=['Rank'])
-                            
-                        #     # Recalculate Rank after filtering
-                        #     filtered_df = filtered_df.reset_index(drop=True)
-                        #     filtered_df.insert(0, 'Rank', range(1, len(filtered_df) + 1))
-                            
-                        #     # Ensure selected columns are present
-                        #     selected_cols = [col for col in selected_cols if col in filtered_df.columns]
-                            
-                        #     return filtered_df[selected_cols]
-                        
-                        # # Bind the filter function to the appropriate events
-                        # filter_inputs_3c3h = [
-                        #     search_box_retrieval,
-                        #     precision_filter_retrieval,
-                        #     license_filter_retrieval,
-                        # ]
-                        # search_box_retrieval.submit(
-                        #     filter_df_3c3h,
-                        #     inputs=filter_inputs_3c3h,
-                        #     outputs=leaderboard_3c3h
-                        # )
+                        # Submit the search box and the leaderboard
+                        search_box_retrieval.submit(
+                            search_leaderboard,
+                            inputs=search_box_retrieval,
+                            outputs=retrieval_leaderboard
+                        )
                         
-                        # # Bind change events for CheckboxGroups and sliders
-                        # for component in filter_inputs_3c3h:
-                        #     component.change(
-                        #         filter_df_3c3h,
-                        #         inputs=filter_inputs_3c3h,
-                        #         outputs=leaderboard_3c3h
-                        #     )
-                    
-                    submit_gradio_module()
+                    submit_gradio_module("Retriever")
 
             with gr.Tab("Reranking"):
                 with gr.Tabs():
                     with gr.Tab("Leaderboard"):
-                        
-                        with gr.Row():
-                            search_box_tasks = gr.Textbox(
+                        search_box_reranker = gr.Textbox(
                                 placeholder="Search for models...", 
                                 label="Search", 
                                 interactive=True
                             )
-                        with gr.Row():
-                            column_selector_tasks = gr.CheckboxGroup(
-                                choices=[],
-                                value=['Rank', 'Model Name'],
-                                label="Select columns to display",
-                            )
-                        with gr.Row():
-                            license_filter_tasks = gr.CheckboxGroup(
-                                choices=[],
-                                value=[],  # Default all selected
-                                label="Filter by License",
-                            )
-                            precision_filter_tasks = gr.CheckboxGroup(
-                                choices=[],
-                                value=[],  # Default all selected
-                                label="Filter by Precision",
-                            )
-                        # with gr.Row():
-                        #     model_size_min_filter_tasks = gr.Slider(
-                        #         minimum=min_model_size_tasks,
-                        #         maximum=max_model_size_tasks,
-                        #         value=min_model_size_tasks,
-                        #         step=1,
-                        #         label="Minimum Model Size",
-                        #         interactive=True
-                        #     )
-                        #     model_size_max_filter_tasks = gr.Slider(
-                        #         minimum=min_model_size_tasks,
-                        #         maximum=max_model_size_tasks,
-                        #         value=max_model_size_tasks,
-                        #         step=1,
-                        #         label="Maximum Model Size",
-                        #         interactive=True
-                        #     )
                         
-                        leaderboard_tasks = gr.Dataframe(
+                        reranker_leaderboard = gr.Dataframe(
                             df,
-                            # headers="auto",  # Automatically use DataFrame's headers
-                            # label="MultiIndex DataFrame",
-                            # interactive=False,
-                        )
-                        
-                        # def filter_df_tasks(search_query, selected_cols, precision_filters, license_filters, min_size, max_size):
-                        #     filtered_df = df_tasks.copy()
-                            
-                        #     # Ensure min_size <= max_size
-                        #     if min_size > max_size:
-                        #         min_size, max_size = max_size, min_size
-                            
-                        #     # Apply search filter
-                        #     if search_query:
-                        #         filtered_df = filtered_df[filtered_df['Model Name'].str.contains(search_query, case=False, na=False)]
-                            
-                        #     # Apply Precision filter
-                        #     if precision_filters:
-                        #         include_missing = 'Missing' in precision_filters
-                        #         selected_precisions = [p for p in precision_filters if p != 'Missing']
-                        #         if include_missing:
-                        #             filtered_df = filtered_df[
-                        #                 (filtered_df['Precision'].isin(selected_precisions)) |
-                        #                 (filtered_df['Precision'] == 'UNK') |
-                        #                 (filtered_df['Precision'].isna())
-                        #             ]
-                        #         else:
-                        #             filtered_df = filtered_df[filtered_df['Precision'].isin(selected_precisions)]
-                            
-                        #     # Apply License filter
-                        #     if license_filters:
-                        #         include_missing = 'Missing' in license_filters
-                        #         selected_licenses = [l for l in license_filters if l != 'Missing']
-                        #         if include_missing:
-                        #             filtered_df = filtered_df[
-                        #                 (filtered_df['License'].isin(selected_licenses)) |
-                        #                 (filtered_df['License'] == 'UNK') |
-                        #                 (filtered_df['License'].isna())
-                        #             ]
-                        #         else:
-                        #             filtered_df = filtered_df[filtered_df['License'].isin(selected_licenses)]
-                            
-                        #     # Apply Model Size filter
-                        #     filtered_df = filtered_df[
-                        #         (filtered_df['Model Size Filter'] >= min_size) &
-                        #         (filtered_df['Model Size Filter'] <= max_size)
-                        #     ]
-                            
-                        #     # Remove existing 'Rank' column if present
-                        #     if 'Rank' in filtered_df.columns:
-                        #         filtered_df = filtered_df.drop(columns=['Rank'])
-                            
-                        #     # Sort by the first task column if it exists
-                        #     if task_columns:
-                        #         first_task = task_columns[0]
-                        #         filtered_df = filtered_df.sort_values(by=first_task, ascending=False)
-                        #     else:
-                        #         filtered_df = filtered_df.sort_values(by='Model Name', ascending=True)
-                            
-                        #     # Recalculate Rank after filtering
-                        #     filtered_df = filtered_df.reset_index(drop=True)
-                        #     filtered_df.insert(0, 'Rank', range(1, len(filtered_df) + 1))
-                            
-                        #     # Ensure selected columns are present
-                        #     selected_cols = [col for col in selected_cols if col in filtered_df.columns]
-                            
-                        #     return filtered_df[selected_cols]
-                        
-                        # # Bind the filter function to the appropriate events
-                        # filter_inputs_tasks = [
-                        #     search_box_tasks,
-                        #     column_selector_tasks,
-                        #     precision_filter_tasks,
-                        #     license_filter_tasks,
-                        #     model_size_min_filter_tasks,
-                        #     model_size_max_filter_tasks
-                        # ]
-                        # search_box_tasks.submit(
-                        #     filter_df_tasks,
-                        #     inputs=filter_inputs_tasks,
-                        #     outputs=leaderboard_tasks
-                        # )
-                        
-                        # # Bind change events for CheckboxGroups and sliders
-                        # for component in filter_inputs_tasks:
-                        #     component.change(
-                        #         filter_df_tasks,
-                        #         inputs=filter_inputs_tasks,
-                        #         outputs=leaderboard_tasks
-                        #     )
+                            interactive=False,
+                            )
 
-                    submit_gradio_module()
+                        search_box_reranker.submit(
+                            search_leaderboard,
+                            inputs=search_box_reranker,
+                            outputs=reranker_leaderboard
+                        )
+                    submit_gradio_module("Reranker")
                     
-            with gr.Tab("LLM Context Answering"):
-                with gr.Tabs():
-                    with gr.Tab("Leaderboard"):
-                        pass
-                    with gr.Tab("Submit Here"):
-                        pass
+            # with gr.Tab("LLM Context Answering"):
+            #     with gr.Tabs():
+            #         with gr.Tab("Leaderboard"):
+            #             pass
+            #         submit_gradio_module("LLM")
 
             with gr.Row():
                 with gr.Accordion("📙 Citation", open=False):

requirements.txt

@@ -0,0 +1 @@
+fuzzywuzzy

utils.py

@@ -50,7 +50,7 @@ def submit_model(model_name, revision, precision, params, license):
     if df_retrieval.empty:
         return "**Error: Could not load the retrieval results.**"
     
-    existing_models_results = df_retrieval[['Model', 'Revision', 'Precision']]
+    existing_models_results = df_retrieval[['Model']]
 
     # Handle 'Missing' precision
     if precision == 'Missing':
@@ -137,7 +137,7 @@ def load_requests(status_folder):
     requests_data = []
     folder_path_in_repo = status_folder  # 'pending', 'finished', or 'failed'
 
-    hf_api_token = os.environ.get('HF_API_TOKEN', None)
+    hf_api_token = os.environ.get('HF_TOKEN', None)
 
     try:
         # List files in the dataset repository
@@ -174,9 +174,9 @@ def load_requests(status_folder):
     return df
 
 
-def submit_gradio_module():
-    with gr.Tab("Submit Model") as submitter_tab: 
+def submit_gradio_module(type):
 
+    with gr.Tab(f"Submit {type}") as submitter_tab: 
         with gr.Row(equal_height=True):
             model_name_input = gr.Textbox(
                 label="Model",