new accuracy compation with fixed population size and retrieval of historical data from cloud storage

scripts/cloud_storage.py

@@ -2,15 +2,15 @@ from minio import Minio
 from minio.error import S3Error
 import os
 import argparse
-
-from utils import HIST_DIR, ROOT_DIR
+import pandas as pd
+from datetime import datetime
+from utils import HIST_DIR, ROOT_DIR, TMP_DIR
 
 MINIO_ENDPOINT = "minio.autonolas.tech"
 ACCESS_KEY = os.environ.get("CLOUD_ACCESS_KEY", None)
 SECRET_KEY = os.environ.get("CLOUD_SECRET_KEY", None)
 BUCKET_NAME = "weekly-stats"
 FOLDER_NAME = "historical_data"
-APRIL_FOLDER = "april2024"
 
 
 def initialize_client():
@@ -85,6 +85,55 @@ def process_historical_files(client):
                 print(f"Error processing {filename}: {str(e)}")
 
 
+def download_tools_historical_files(
+    client, exclude_filename: str = None, nr_files: int = 18
+) -> pd.DataFrame:
+    """Download the last nr_files tools files from the cloud storage"""
+    FILES_IN_TWO_MONTHS = 16
+    try:
+        print(f"Downloading the last {nr_files} tools files from cloud storage")
+        # Use recursive=True to get all objects including those in subfolders
+        objects = client.list_objects(
+            BUCKET_NAME, prefix=FOLDER_NAME + "/", recursive=True
+        )
+        all_objects = list(objects)
+        print(f"Total objects found: {len(all_objects)}")
+
+        tool_files = [
+            obj.object_name
+            for obj in all_objects
+            if obj.object_name.endswith(".parquet") and "tools" in obj.object_name
+        ]
+        print(f"tool files found: {tool_files}")
+        if len(tool_files) < nr_files - 1:  # at least one file to collect
+            return None
+        # format of the filename is tools_YYYYMMDD_HHMMSS.parquet
+        # get the last nr_files by sorting the tool_files by the YYYYMMDD_HHMMSS part
+        tool_files.sort()  # Sort files by name (assumed to be timestamped)
+        selected_files = tool_files[-nr_files:]  # Get the last nr_files
+
+        print(f"Selected files: {selected_files}")
+        # traverse the selected files in reverse order
+        selected_files.reverse()
+        # skip the first FILES_IN_TWO_MONTHS files
+        selected_files = selected_files[
+            FILES_IN_TWO_MONTHS:
+        ]  # limit to last two months
+
+        for filename in selected_files:
+            if exclude_filename and exclude_filename in filename:
+                continue
+            local_filename = filename.replace("historical_data/", "")
+            print(f"Downloading {local_filename}")
+            download_path = TMP_DIR / local_filename
+            client.fget_object(BUCKET_NAME, filename, str(download_path))
+            return local_filename
+    except S3Error as err:
+        print(f"Error downloading files: {err}")
+
+    return None
+
+
 if __name__ == "__main__":
     # parser = argparse.ArgumentParser(
     #     description="Load files to the cloud storate for historical data"
@@ -96,7 +145,8 @@ if __name__ == "__main__":
     # filename = args.param_1
 
     client = initialize_client()
-    download_file(client, "all_trades_profitability_20250103_162106.parquet")
+    # download_file(client, "all_trades_profitability_20250103_162106.parquet")
+    download_tools_historical_files(client)
     # load_historical_file(client, filename)
     # process_historical_files(client)
     # checking files at the cloud storage

scripts/update_tools_accuracy.py

@@ -5,7 +5,9 @@ import ipfshttpclient
 from utils import INC_TOOLS
 from typing import List
 from utils import TMP_DIR, ROOT_DIR
+from cloud_storage import initialize_client, download_tools_historical_files
 import math
+import time
 
 ACCURACY_FILENAME = "tools_accuracy.csv"
 IPFS_SERVER = "/dns/registry.autonolas.tech/tcp/443/https"
@@ -13,6 +15,8 @@ GCP_IPFS_SERVER = "/dns/registry.gcp.autonolas.tech/tcp/443/https"
 SAMPLING_POPULATION_SIZE = 800
 NR_SUBSETS = 100
 SAMPLES_THRESHOLD = 50
+DEFAULT_ACCURACY = 51.0
+LAST_MODEL_UPDATE = "2025-06-03"
 
 
 def mean_and_std(numbers):
@@ -22,7 +26,7 @@ def mean_and_std(numbers):
     return mean, std_dev
 
 
-def clean_tools_df(tools_df: pd.DataFrame) -> pd.DataFrame:
+def clean_tools_dataset(tools_df: pd.DataFrame) -> pd.DataFrame:
 
     # Remove tool_name and TEMP_TOOL
     tools_non_error = tools_df[
@@ -44,37 +48,32 @@ def clean_tools_df(tools_df: pd.DataFrame) -> pd.DataFrame:
     return tools_non_error
 
 
-def separate_sampling_tools(
-    tools_df: pd.DataFrame, sample_size: int
-) -> Tuple[Dict, Dict, Dict]:
+def classify_tools(tools_df: pd.DataFrame, sample_size: int) -> Tuple[Dict, Dict, Dict]:
     """
-    Separates tools into two groups based on whether they need downsampling or upsampling
+    Separates tools into different groups based on two use-cases:
+    1. Tools with enough samples to reach sample_size
+    2. Tools with not enough samples to reach sample_size
 
     Args:
         tools_df: DataFrame containing the tools data
         sample_size: Target number of samples for each tool
 
     Returns:
-        Tuple of two dictionaries containing tools that need downsampling and upsampling
+        Tuple of two dictionaries containing tools that are from group 1 and group 2
     """
     # Get count of samples per tool
     tool_counts = tools_df["tool"].value_counts()
 
     # Separate tools based on sample size
-    downsample_tools = {
-        tool: count for tool, count in tool_counts.items() if count > sample_size
+    valid_tools = {
+        tool: count for tool, count in tool_counts.items() if count >= sample_size
     }
-    # edge case: if the tools has less samples than the samples_threshold, we skip it
-    skipped_tools = {
-        tool: count for tool, count in tool_counts.items() if count < SAMPLES_THRESHOLD
-    }
-    upsample_tools = {
-        tool: count
-        for tool, count in tool_counts.items()
-        if count > SAMPLES_THRESHOLD and count < sample_size
+
+    more_samples_tools = {
+        tool: count for tool, count in tool_counts.items() if count < sample_size
     }
 
-    return downsample_tools, upsample_tools, skipped_tools
+    return valid_tools, more_samples_tools
 
 
 def downsample_tool_multiple(
@@ -111,6 +110,24 @@ def downsample_tool_multiple(
     return downsampled_sets
 
 
+def get_recent_samples(tool_samples: pd.DataFrame, sample_size: int) -> pd.DataFrame:
+    """
+    Gets the most recent samples from the tool samples
+
+    Args:
+        tool_samples: DataFrame containing samples for a specific tool
+        sample_size: Number of samples to select
+
+    Returns:
+        DataFrame containing the most recent samples
+    """
+    if len(tool_samples) < sample_size:
+        raise ValueError(
+            f"Not enough samples available: {len(tool_samples)} < {sample_size}"
+        )
+    return tool_samples.nlargest(sample_size, "request_time")
+
+
 def upsample_tool_multiple(
     tool_samples: pd.DataFrame, sample_size: int, n_subsets: int
 ) -> List[pd.DataFrame]:
@@ -162,7 +179,7 @@ def compute_subset_accuracy(tools_subset: pd.DataFrame) -> float:
     return (wins[1] / (wins[0] + wins[1])) * 100
 
 
-def compute_tool_accuracy(subset_list: List[pd.DataFrame]) -> Tuple:
+def compute_tool_estimated_accuracy(subset_list: List[pd.DataFrame]) -> Tuple:
     """
     Computes the accuracy for the tool averaging the accuracy achieved within the list of subsets.
 
@@ -183,6 +200,84 @@ def compute_tool_accuracy(subset_list: List[pd.DataFrame]) -> Tuple:
     return accuracy_mean, accuracy_std
 
 
+def update_global_accuracy(
+    valid_tools: Dict,
+    tools_df: pd.DataFrame,
+    global_accuracies: Dict,
+    sample_size: int,
+    one_tool: str = None,
+) -> Dict:
+    """
+    Updates the global accuracies for tools that have enough samples.
+
+    Args:
+        valid_tools: Dictionary of tools with enough samples
+        global_accuracies: Dictionary to store global accuracies
+        sample_size: Target number of samples for each tool
+        one_tool: Optional specific tool to compute accuracy for
+
+    Returns:
+        Updated global accuracies dictionary
+    """
+    if one_tool:
+        print(f"Computing accuracy for tool: {one_tool}")
+        tool_samples = tools_df[tools_df["tool"] == one_tool]
+        if len(tool_samples) < sample_size:
+            print(f"Not enough samples for tool {one_tool}, skipping")
+            return global_accuracies
+        recent_samples = get_recent_samples(tool_samples, sample_size)
+        global_accuracies[one_tool] = {
+            "mean": compute_subset_accuracy(recent_samples),
+            "std": 0.0,  # No standard deviation for a single sample
+        }
+        return global_accuracies
+
+    for tool in valid_tools.keys():
+        print(f"Processing tool: {tool}")
+        tool_samples = tools_df[tools_df["tool"] == tool]
+        # Get the most recent samples for the tool
+        recent_samples = get_recent_samples(tool_samples, sample_size)
+        global_accuracies[tool] = {
+            "mean": compute_subset_accuracy(recent_samples),
+            "std": 0.0,  # No standard deviation for a single sample
+        }
+
+
+def adding_historical_data(
+    tools_historical_file: str,
+    tools_df: pd.DataFrame,
+    more_sample_tools: Dict,
+    sample_size: int,
+    valid_tools: Dict,
+    global_accuracies: Dict,
+):
+    if tools_historical_file:
+        tool_names = list(more_sample_tools.keys())
+        print(f"Downloaded historical file: {tools_historical_file}")
+        # Load the historical tools data
+        historical_tools_df = pd.read_parquet(TMP_DIR / tools_historical_file)
+        # check if the historical tools data has samples from the tools that need more samples
+        historical_tools_df = historical_tools_df[
+            historical_tools_df["tool"].isin(tool_names)
+        ]
+        # Combine the current tools with the historical ones
+        tools_df = pd.concat([tools_df, historical_tools_df], ignore_index=True)
+        # check the volume of samples for the tools in the historical data
+        historical_tool_counts = historical_tools_df["tool"].value_counts()
+    for tool, count in historical_tool_counts.items():
+        current_count = more_sample_tools.get(tool, 0)
+        if count + current_count >= sample_size:
+            print(f"Tool {tool} has enough samples now: {count + current_count}")
+            valid_tools[tool] = count + current_count
+            update_global_accuracy(
+                valid_tools, tools_df, global_accuracies, sample_size, one_tool=tool
+            )
+            # Remove the tool from more_sample_tools
+            if tool in more_sample_tools:
+                print(f"Deleting tool {tool} from more_sample_tools")
+                del more_sample_tools[tool]
+
+
 def compute_global_accuracy_same_population(
     tools_df: pd.DataFrame,
     sample_size: int = SAMPLING_POPULATION_SIZE,
@@ -200,41 +295,71 @@ def compute_global_accuracy_same_population(
     Returns:
         List of global accuracies for the tools
     """
-    downsample_tools, upsample_tools, skipped_tools = separate_sampling_tools(
-        tools_df, sample_size
-    )
+    valid_tools, more_sample_tools = classify_tools(tools_df, sample_size)
     global_accuracies = {}
 
-    # Process tools that need downsampling
-    for tool in downsample_tools.keys():
-        print(f"Processing tool: {tool}")
-        tool_samples = tools_df[tools_df["tool"] == tool]
-        downsampled_sets = downsample_tool_multiple(
-            tool_samples, sample_size, n_subsets
-        )
-
-        tool_mean_accuracy, tool_std = compute_tool_accuracy(downsampled_sets)
-        global_accuracies[tool] = {"mean": float(tool_mean_accuracy), "std": tool_std}
-
+    # Compute the accuracy for tools in valid_tools
+    update_global_accuracy(valid_tools, tools_df, global_accuracies, sample_size)
+
+    # Check historical files for tools that need more samples
+    client = initialize_client()
+    # first historical file download
+    tool_names = list(more_sample_tools.keys())
+    print(f"Tools with not enough samples: {tool_names}")
+    # Disbling the historical file download til we have enough old samples from "2025-06-03" (Latest model update)
+    # TODO reactivate the historical file download from 2025-08-16
+    # tools_historical_file = download_tools_historical_files(
+    #     client, exclude_filename=None
+    # )
+    # adding_historical_data(
+    #     tools_historical_file,
+    #     tools_df,
+    #     more_sample_tools,
+    #     sample_size,
+    #     valid_tools,
+    #     global_accuracies,
+    # )
+    # if len(more_sample_tools) > 0:
+    #     # second historical file download
+    #     tools_historical_file2 = download_tools_historical_files(
+    #         client,
+    #         exclude_filename=tools_historical_file,
+    #     )
+    #     adding_historical_data(
+    #         tools_historical_file2,
+    #         tools_df,
+    #         more_sample_tools,
+    #         sample_size,
+    #         valid_tools,
+    #         global_accuracies,
+    #     )
+    # if not enough samples found in the historical data, upsample the tools that need more samples
     # Process tools that need upsampling
-    for tool in upsample_tools.keys():
+    for tool in more_sample_tools.keys():
+        if more_sample_tools[tool] < SAMPLES_THRESHOLD:
+            # assign the default accuracy
+            print(f"Tool {tool} has not enough samples, assigning default accuracy")
+            global_accuracies[tool] = {
+                "mean": DEFAULT_ACCURACY,
+                "std": 0.0,  # No standard deviation for a single sample
+            }
+            continue
+        print(f"Upsampling tool: {tool}")
         tool_samples = tools_df[tools_df["tool"] == tool]
         upsampled_sets = upsample_tool_multiple(tool_samples, sample_size, n_subsets)
 
-        tool_mean_accuracy, tool_std = compute_tool_accuracy(upsampled_sets)
+        tool_mean_accuracy, tool_std = compute_tool_estimated_accuracy(upsampled_sets)
         global_accuracies[tool] = {"mean": float(tool_mean_accuracy), "std": tool_std}
-    return global_accuracies, skipped_tools
+    return global_accuracies
 
 
 def get_accuracy_info(tools_df: pd.DataFrame) -> [pd.DataFrame, bool, Dict]:
     """
     Extracts accuracy information from the tools DataFrame.
     """
-    clean_tools_df = clean_tools_df(tools_df)
+    clean_tools_df = clean_tools_dataset(tools_df)
     # compute global accuracy information for the tools
-    global_accuracies, skipped_tools = compute_global_accuracy_same_population(
-        tools_df=clean_tools_df
-    )
+    global_accuracies = compute_global_accuracy_same_population(tools_df=clean_tools_df)
     # transform the dictionary global_accuracies into a DataFrame
     wins = pd.DataFrame(
         [
@@ -260,7 +385,7 @@ def get_accuracy_info(tools_df: pd.DataFrame) -> [pd.DataFrame, bool, Dict]:
         print("NO REQUEST TIME INFORMATION AVAILABLE")
         no_timeline_info = True
         acc_info = wins
-    return acc_info, no_timeline_info, skipped_tools
+    return acc_info, no_timeline_info
 
 
 def update_tools_accuracy_same_model(
@@ -270,8 +395,7 @@ def update_tools_accuracy_same_model(
 
     # computation of the accuracy information
     tools_inc = tools_df[tools_df["tool"].isin(inc_tools)]
-    acc_info, no_timeline_info, skipped_tools = get_accuracy_info(tools_inc)
-    print(f"Skipped tools in the update with not enough samples: {skipped_tools}")
+    acc_info, no_timeline_info = get_accuracy_info(tools_inc)
 
     if tools_acc is None:
         print("Creating accuracy file for the first time")
@@ -285,9 +409,15 @@ def update_tools_accuracy_same_model(
     # dt.strftime("%Y-%m-%d %H:%M:%S")
     acc_info["min"] = acc_info["min"].dt.strftime("%Y-%m-%d %H:%M:%S")
     acc_info["max"] = acc_info["max"].dt.strftime("%Y-%m-%d %H:%M:%S")
+    new_tools = []
+    all_accuracies = []
     for tool in tools_to_update:
-        new_accuracy = acc_info[acc_info["tool"] == tool]["tool_accuracy"].values[0]
-        new_volume = acc_info[acc_info["tool"] == tool]["total_requests"].values[0]
+        new_accuracy = round(
+            acc_info[acc_info["tool"] == tool]["tool_accuracy"].values[0], 2
+        )
+        all_accuracies.append(new_accuracy)
+        # accuracy has been computed over the same population size
+        new_volume = SAMPLING_POPULATION_SIZE
         if no_timeline_info:
             new_min_timeline = None
             new_max_timeline = None
@@ -311,17 +441,28 @@ def update_tools_accuracy_same_model(
             tools_acc.loc[tools_acc["tool"] == tool, "min"] = new_min_timeline
             tools_acc.loc[tools_acc["tool"] == tool, "max"] = new_max_timeline
         else:
-            # new tool to add to the file
+            new_tools.append(tool)
+
+    # compute the average accuracy for the existing tools
+    if len(new_tools) > 0:
+        print(f"New tools added: {new_tools}")
+        # compute the average accuracy for the new tools
+        avg_accuracy = (
+            round(sum(all_accuracies) / len(all_accuracies), 2)
+            if len(all_accuracies) > 0
+            else DEFAULT_ACCURACY
+        )
+        print(f"Average accuracy for new tools: {avg_accuracy}")
+        for tool in new_tools:
             # tool,tool_accuracy,total_requests,min,max
             new_row = {
                 "tool": tool,
-                "tool_accuracy": new_accuracy,
-                "total_requests": new_volume,
-                "min": new_min_timeline,
-                "max": new_max_timeline,
+                "tool_accuracy": avg_accuracy,
+                "total_requests": SAMPLING_POPULATION_SIZE,
+                "min": None,
+                "max": None,
             }
             tools_acc = pd.concat([tools_acc, pd.DataFrame(new_row)], ignore_index=True)
-
     print(tools_acc)
     return tools_acc
 
@@ -340,15 +481,16 @@ def update_tools_accuracy(
     tools_df["request_date"] = pd.to_datetime(tools_df["request_date"])
     tools_df["request_date"] = tools_df["request_date"].dt.strftime("%Y-%m-%d")
     # split the data into two parts: before and after the 3rd of June
-    split_date = pd.to_datetime("2025-06-03").tz_localize("UTC")
+    split_date = pd.to_datetime(LAST_MODEL_UPDATE).tz_localize("UTC")
     before_split = tools_df[tools_df["request_time"] < split_date]
     after_split = tools_df[tools_df["request_time"] >= split_date]
     print(f"Number of requests before {split_date}: {len(before_split)}")
     print(f"Number of requests after {split_date}: {len(after_split)}")
     # compute the accuracy information for the two parts
-    acc_info_before = update_tools_accuracy_same_model(
-        old_tools_acc, before_split, inc_tools
-    )
+    # acc_info_before = update_tools_accuracy_same_model(
+    #     old_tools_acc, before_split, inc_tools
+    # )
+    acc_info_before = None
     acc_info_after = update_tools_accuracy_same_model(tools_acc, after_split, inc_tools)
     # return the two different dataframes
     return acc_info_before, acc_info_after
@@ -374,7 +516,7 @@ def compute_tools_accuracy():
 
     # save acc_data into a CSV file
     print("Saving into a csv files")
-    old_acc_data.to_csv(ROOT_DIR / "old_tools_accuracy.csv", index=False)
+    # old_acc_data.to_csv(ROOT_DIR / "old_tools_accuracy.csv", index=False)
     new_acc_data.to_csv(ROOT_DIR / ACCURACY_FILENAME, index=False)
     # save the data into IPFS
     # push_csv_file_to_ipfs("old_tools_accuracy.csv")

tools_accuracy.csv

@@ -1,13 +1,13 @@
 tool,tool_accuracy,total_requests,min,max
-claude-prediction-offline,60.66080040612572,132980,2025-05-25 10:30:10,2025-07-20 23:30:50
-claude-prediction-online,54.01045556385362,128324,2025-05-25 00:00:15,2025-07-20 23:10:30
-prediction-offline,61.649646337713015,1495882,2025-05-25 00:00:30,2025-07-20 23:42:15
-prediction-offline-sme,56.35491606714629,3706,2025-05-25 00:13:15,2025-07-17 12:28:50
-prediction-online,60.34185039665657,276866,2025-05-25 07:33:20,2025-07-20 23:41:50
-prediction-online-sme,55.158180430296,237421,2025-05-25 07:05:50,2025-07-20 23:38:00
-prediction-request-rag,48.651197887191096,162605,2025-05-25 14:16:25,2025-07-20 23:38:30
-prediction-request-rag-claude,46.08523290386521,3501,2025-05-25 13:21:55,2025-07-20 19:25:25
-prediction-request-reasoning,54.98439809492528,485638,2025-05-25 07:14:15,2025-07-20 23:43:45
-prediction-request-reasoning-claude,51.8555667001003,3164,2025-05-25 13:48:00,2025-07-20 17:57:35
-prediction-url-cot-claude,42.857142857142854,362,2025-05-25 00:12:40,2025-07-01 07:40:40
-superforcaster,63.83774090070976,298068,2025-05-25 00:00:20,2025-07-20 23:42:00
+claude-prediction-offline,61.25,800,2025-06-06 00:13:05,2025-07-20 23:30:50
+claude-prediction-online,44.25,800,2025-06-11 07:23:05,2025-07-20 23:10:30
+prediction-offline,66.25,800,2025-06-03 00:00:05,2025-07-20 23:42:15
+prediction-offline-sme,56.44,800,2025-06-03 11:55:10,2025-07-17 12:28:50
+prediction-online,48.25,800,2025-06-03 00:00:05,2025-07-20 23:41:50
+prediction-online-sme,61.12,800,2025-06-03 00:04:30,2025-07-20 23:38:00
+prediction-request-rag,43.25,800,2025-06-03 18:59:40,2025-07-20 23:38:30
+prediction-request-rag-claude,44.38,800,2025-06-03 17:51:10,2025-07-20 19:25:25
+prediction-request-reasoning,54.25,800,2025-06-03 00:00:30,2025-07-20 23:43:45
+prediction-request-reasoning-claude,53.5,800,2025-06-16 11:02:15,2025-07-20 17:57:35
+prediction-url-cot-claude,51.0,800,2025-06-12 20:36:25,2025-07-01 07:40:40
+superforcaster,62.75,800,2025-06-03 01:15:10,2025-07-20 23:42:00