updating tools accuracy computation and csv file

scripts/global_tool_accuracy.py

@@ -15,6 +15,9 @@ from cloud_storage import (
     FILES_IN_TEN_MONTHS,
 )
 
+ACCURACY_FILENAME = "tools_accuracy.csv"
+IPFS_SERVER = "/dns/registry.autonolas.tech/tcp/443/https"
+NR_ANSWERED_MARKETS = 800  # In two months the max we can reach is 1000 for top tools
 MAX_ATTEMPTS = 5
 historical_files_count_map = {
     1: FILES_IN_TWO_MONTHS,
@@ -23,6 +26,23 @@ historical_files_count_map = {
     4: FILES_IN_EIGHT_MONTHS,
     5: FILES_IN_TEN_MONTHS,
 }
+DEFAULT_ACCURACY = 0.50
+
+
+def keep_last_answer_per_question_per_tool(
+    clean_tools_df: pd.DataFrame,
+) -> pd.DataFrame:
+    """
+    For each tool, keep only the last answer for each question (title) based on request_time.
+    Returns a filtered DataFrame.
+    """
+    # Sort by tool, title, and request_time
+    sorted_df = clean_tools_df.sort_values(by=["tool", "title", "request_time"])
+    # Keep the last answer for each tool and question
+    last_answers = sorted_df.groupby(["tool", "title"], as_index=False).tail(1)
+    # Reset index for cleanliness
+    last_answers = last_answers.reset_index(drop=True)
+    return last_answers
 
 
 def push_csv_file_to_ipfs(filename: str = ACCURACY_FILENAME) -> str:
@@ -60,19 +80,6 @@ def take_toptool_name(tools_df: pd.DataFrame) -> str:
     return volumes.iloc[0].tool
 
 
-def keep_last_answer_per_question_per_tool(clean_tools_df: pd.DataFrame) -> None:
-    for tool in INC_TOOLS:
-        print(f"checking answers from tool {tool}")
-        tool_data = clean_tools_df[clean_tools_df["tool"] == tool]
-        # sort tool_data by request date in ascending order
-        tool_data = tool_data.sort_values(by="request_time", ascending=True)
-
-        unique_questions = tool_data.title.unique()
-        for question in unique_questions:
-            market_data = tool_data[tool_data["title"] == question]
-            market_data = market_data.sort_values(by="request_time", ascending=True)
-
-
 def compute_nr_questions_per_tool(clean_tools_df: pd.DataFrame) -> dict:
     answered_questions = {}
 
@@ -111,7 +118,7 @@ def classify_tools_by_responses(
     more_questions_tools = []
     total_tools = answered_questions.keys()
     for tool in total_tools:
-        if answered_questions[tool] >= ref_nr_questions:
+        if answered_questions[tool]["total_answered_questions"] >= ref_nr_questions:
             enough_questions_tools.append(tool)
         else:
             more_questions_tools.append(tool)
@@ -153,7 +160,11 @@ def add_historical_data(
         new_count = answered_questions[tool]["total_answered_questions"]
         if new_count >= recent_nr_questions:
             completed_tools.append(tool)
-    # TODO remove the tools in completed_tools list from more_questions_tools
+    # remove the tools in completed_tools list from more_questions_tools
+    for tool in completed_tools:
+        print(f"Tool {tool} with enough questions now, removing from list")
+        if tool in more_questions_tools:
+            more_questions_tools.remove(tool)
     return tools_df
 
 
@@ -166,7 +177,7 @@ def check_historical_samples(
 ) -> Tuple:
     """
     Function to download historical data from tools and to update the list
-    of tools that need more questions. It returns a list of the tools that we
+    of tools that need more questions. It returns the updated dataframe and a list of the tools that we
     managed to complete the requirement
     """
     print(f"Tools with not enough samples: {more_questions_tools}")
@@ -184,10 +195,47 @@ def check_historical_samples(
         ref_nr_questions,
         completed_tools,
     )
-    # TODO for each tool in tools_df, take the last answer only for each question based on request_time
+    #  for each tool in tools_df, take the last answer only for each question ("title" column) based on request_time column
+    tools_df = keep_last_answer_per_question_per_tool(tools_df)
     return tools_df, completed_tools
 
 
+def get_accuracy_values(tools_df: pd.DataFrame, more_q_tools: list) -> list:
+    global_accuracies = []
+    tools = tools_df.tool.unique()
+    for tool in tools:
+        tools_data = tools_df[tools_df["tool"] == tool]
+        min_timestamp = tools_data.request_time.min().strftime("%Y-%m-%d %H:%M:%S")
+        max_timestamp = tools_data.request_time.max().strftime("%Y-%m-%d %H:%M:%S")
+        if tool in more_q_tools:
+            global_accuracies.append(
+                {
+                    "tool": tool,
+                    "accuracy": None,
+                    "nr_responses": NR_ANSWERED_MARKETS,
+                    "min": min_timestamp,
+                    "max": max_timestamp,
+                }
+            )
+            continue
+
+        # win column ==1 is a correct answer
+        correct_answers = int(tools_data.win.sum())
+        tool_accuracy = round(correct_answers / len(tools_data), 5)
+        # no values under 50%
+        tool_accuracy = max(DEFAULT_ACCURACY, tool_accuracy)
+        global_accuracies.append(
+            {
+                "tool": tool,
+                "accuracy": tool_accuracy,
+                "nr_responses": NR_ANSWERED_MARKETS,
+                "min": min_timestamp,
+                "max": max_timestamp,
+            }
+        )
+    return global_accuracies
+
+
 def global_tool_accuracy():
     # read the tools df
     print("Reading tools parquet file")
@@ -201,15 +249,15 @@ def global_tool_accuracy():
 
     # extract the number of questions answered from the top tool
     answered_questions = compute_nr_questions_per_tool(clean_tools_df=clean_tools_df)
-    ref_nr_questions = answered_questions[top_tool]["total_answered_questions"]
+    ref_nr_questions = NR_ANSWERED_MARKETS
 
     # classify tools between those with enough questions and those that need more data
     enough_q_tools, more_q_tools = classify_tools_by_responses(
         answered_questions, ref_nr_questions
     )
 
-    # TODO for each tool in clean_tools_df, take the last answer only for each question based on request_time
-
+    # for each tool in clean_tools_df, take the last answer only for each question ("title" column) based on request_time column
+    clean_tools_df = keep_last_answer_per_question_per_tool(clean_tools_df)
     # go for historical data if needed up to a maximum of 5 attempts
     nr_attempts = 0
     client = initialize_client()
@@ -218,13 +266,38 @@ def global_tool_accuracy():
         print(f"Attempt {nr_attempts} to reach the reference number of questions")
         clean_tools_df, updated_tools = check_historical_samples(
             client=client,
-            tools_df=tools_df,
+            tools_df=clean_tools_df,
             more_questions_tools=more_q_tools,
             ref_nr_questions=ref_nr_questions,
             attempt_nr=nr_attempts,
         )
-        print(f"Updated tools {updated_tools}")
-        print(f"more tools with missing data {more_q_tools}")
+        print(f"Tools that were completed with historical data {updated_tools}")
+        print(f"More tools with not enough questions {more_q_tools}")
+
+    # compute the accuracy
+    global_accuracies = get_accuracy_values(
+        tools_df=clean_tools_df, more_q_tools=more_q_tools
+    )
+    # new tools + not enough samples
+    if len(more_q_tools) > 0:
+        # compute the average accuracy for the new tools
+        total_accuracy = sum(item["accuracy"] for item in global_accuracies)
+        avg_accuracy = (
+            round(total_accuracy / len(global_accuracies), 5)
+            if len(global_accuracies) > 0
+            else DEFAULT_ACCURACY
+        )
+        for tool in more_q_tools:
+            global_accuracies[tool]["accuracy"] = avg_accuracy
+
+    print(f"global accuracies {global_accuracies}")
+    # create a dataframe from global_accuracies
+    computed_accuracy_df = pd.DataFrame(global_accuracies)
+    print(computed_accuracy_df.head())
+    print("Saving into a csv file")
+    computed_accuracy_df.to_csv(ROOT_DIR / ACCURACY_FILENAME, index=False)
+    # save the data into IPFS
+    # push_csv_file_to_ipfs()
 
 
 if __name__ == "__main__":

tools_accuracy.csv

@@ -1,13 +1,13 @@
-tool,tool_accuracy,total_requests,min,max
-prediction-offline,61.97,500,2025-06-03 00:00:05,2025-08-03 23:44:55
-prediction-online-sme,52.33,500,2025-06-03 00:04:30,2025-08-03 22:49:45
-prediction-online,59.38,500,2025-06-03 00:00:05,2025-08-03 22:31:35
-prediction-request-reasoning,58.02,500,2025-06-03 00:00:30,2025-08-03 23:44:40
-claude-prediction-offline,57.92,500,2025-06-06 00:13:05,2025-08-03 21:46:10
-claude-prediction-online,57.92,500,2025-06-11 07:23:05,2025-08-03 23:02:15
-superforcaster,57.92,500,2025-06-03 01:15:10,2025-08-03 22:50:05
-prediction-request-reasoning-claude,57.92,500,2025-06-16 11:02:15,2025-08-03 22:59:10
-prediction-request-rag-claude,57.92,500,2025-06-03 17:51:10,2025-08-03 22:52:10
-prediction-offline-sme,57.92,500,2025-06-03 11:55:10,2025-08-02 07:55:50
-prediction-url-cot-claude,57.92,500,2025-06-12 20:36:25,2025-07-27 08:15:15
-prediction-request-rag,57.92,500,2025-06-03 18:59:40,2025-08-03 21:23:40
+tool,accuracy,nr_responses,min,max
+claude-prediction-offline,0.59785,800,2025-06-11 22:43:20,2025-08-10 23:28:40
+claude-prediction-online,0.57552,800,2025-06-12 07:00:35,2025-08-11 02:47:25
+prediction-offline,0.65566,800,2025-06-10 19:23:15,2025-08-10 23:44:45
+prediction-offline-sme,0.5,800,2025-03-18 00:34:45,2025-08-09 09:24:30
+prediction-online,0.65628,800,2025-06-10 09:02:55,2025-08-10 23:30:00
+prediction-online-sme,0.56816,800,2025-06-10 04:40:00,2025-08-10 23:39:40
+prediction-request-rag,0.59852,800,2025-06-11 02:24:45,2025-08-10 23:38:35
+prediction-request-rag-claude,0.5,800,2025-03-18 00:08:15,2025-08-10 19:05:15
+prediction-request-reasoning,0.66068,800,2025-06-10 00:56:45,2025-08-11 02:47:50
+prediction-request-reasoning-claude,0.5,800,2025-03-18 16:35:45,2025-08-10 22:41:50
+prediction-url-cot-claude,0.5,800,2025-01-12 01:30:50,2025-07-27 08:15:15
+superforcaster,0.66273,800,2025-06-10 02:00:30,2025-08-10 19:59:40