Fix gold score on weekends (#188)

* Revert "fix tests"

This reverts commit 20a2fac.

* _transform_data adds nan

* new data transform

* fix unit tests

* remove full_fill_real_prices

* fix compare isnan to store real path in db

---------

Co-authored-by: davidevdt <[email protected]>

Author: Thykof

synth/utils/helpers.py

@@ -1,10 +1,7 @@
-from typing import Optional, Any
+from typing import Optional
 from datetime import datetime, timedelta, timezone
 
 
-import numpy as np
-
-
 def get_current_time() -> datetime:
     # Get current date and time
     return datetime.now(timezone.utc).replace(microsecond=0)
@@ -71,39 +68,6 @@ def adjust_predictions(predictions: list) -> list:
     return predictions[2:]
 
 
-def full_fill_real_prices(
-    prediction: list[dict[str, Any]], real_prices: list[dict[str, Any]]
-) -> list[dict[str, Any]]:
-    """
-    Fills missing real prices in the prediction with None.
-
-    :param prediction: List of dictionaries with 'time' and 'price' keys.
-    :param real_prices: List of dictionaries with 'time' and 'price' keys.
-    :return: List of dictionaries with filled prices.
-    """
-    # transform real_prices into a dictionary for fast lookup
-    real_prices_dict = {}
-    for idx, entry in enumerate(real_prices):
-        real_prices_dict[idx] = entry
-
-    # fill missing times and prices in the real_prices_dict
-    for idx, entry in enumerate(prediction):
-        if (
-            idx not in real_prices_dict
-            or real_prices_dict[idx] is None
-            or np.isnan(real_prices_dict[idx])
-            or not np.isfinite(real_prices_dict[idx])
-        ):
-            real_prices_dict[idx] = np.nan
-
-    real_prices_filled = []
-    # recreate the real_prices list of dict sorted by time
-    for time in sorted(real_prices_dict.keys()):
-        real_prices_filled.append(real_prices_dict[time])
-
-    return real_prices_filled
-
-
 def get_intersecting_arrays(array1, array2):
     """
     Filters two arrays of dictionaries, keeping only entries that intersect by 'time'.

synth/validator/miner_data_handler.py

@@ -3,6 +3,7 @@
 import sys
 import typing
 import logging
+import math
 
 
 import bittensor as bt
@@ -178,10 +179,14 @@ def set_miner_scores(
                 with connection.begin():
                     # update validator request with the real paths
                     if real_prices is not None and len(real_prices) > 0:
-                        # replace np.nan with None
-                        for price in real_prices:
-                            if price is not None and pd.isna(price):
-                                price = None
+                        real_prices = [
+                            (
+                                None
+                                if (isinstance(x, float) and math.isnan(x))
+                                else x
+                            )
+                            for x in real_prices
+                        ]
                         update_stmt_validator = (
                             update(ValidatorRequest)
                             .where(

synth/validator/price_data_provider.py

@@ -8,6 +8,7 @@
     stop_after_attempt,
     wait_random_exponential,
 )
+import numpy as np
 import bittensor as bt
 
 
@@ -62,32 +63,45 @@ def fetch_data(self, validator_request: ValidatorRequest) -> list[dict]:
         data = response.json()
 
         transformed_data = self._transform_data(
-            data, start_time_int, validator_request.time_increment
+            data,
+            start_time_int,
+            validator_request.time_increment,
+            validator_request.time_length,
         )
 
         return transformed_data
 
     @staticmethod
     def _transform_data(
-        data, start_time_int: int, time_increment: int
+        data, start_time_int: int, time_increment: int, time_length: int
     ) -> list:
-        if data is None or len(data) == 0:
+        if data is None or len(data) == 0 or len(data["t"]) == 0:
             return []
 
-        timestamps = data["t"]
-        close_prices = data["c"]
-
-        transformed_data = []
-
-        if len(timestamps) == 0:
-            return []
-
-        for t, c in zip(timestamps, close_prices):
-            if (
-                t >= start_time_int
-                and (t - start_time_int) % time_increment == 0
-            ):
-                transformed_data.append(float(c))
+        time_end_int = start_time_int + time_length
+        timestamps = [
+            t
+            for t in range(
+                start_time_int, time_end_int + time_increment, time_increment
+            )
+        ]
+
+        if len(timestamps) != int(time_length / time_increment) + 1:
+            # Note: this part of code should never be activated; just included for precaution
+            if len(timestamps) == int(time_length / time_increment) + 2:
+                if data["t"][-1] < timestamps[1]:
+                    timestamps = timestamps[:-1]
+                elif data["t"][0] > timestamps[0]:
+                    timestamps = timestamps[1:]
+            else:
+                return []
+
+        close_prices_dict = {t: c for t, c in zip(data["t"], data["c"])}
+        transformed_data = [np.nan for _ in range(len(timestamps))]
+
+        for idx, t in enumerate(timestamps):
+            if t in close_prices_dict:
+                transformed_data[idx] = close_prices_dict[t]
 
         return transformed_data
 

synth/validator/reward.py

@@ -26,7 +26,7 @@
 
 
 from synth.db.models import ValidatorRequest
-from synth.utils.helpers import adjust_predictions, full_fill_real_prices
+from synth.utils.helpers import adjust_predictions
 from synth.validator.crps_calculation import calculate_crps_for_miner
 from synth.validator.miner_data_handler import MinerDataHandler
 from synth.validator.price_data_provider import PriceDataProvider
@@ -64,14 +64,11 @@ def reward(
 
     predictions_path = adjust_predictions(miner_prediction.prediction)
     simulation_runs = np.array(predictions_path).astype(float)
-    full_filled_real_prices = full_fill_real_prices(
-        miner_prediction.prediction[2], real_prices
-    )
 
     try:
         score, detailed_crps_data = calculate_crps_for_miner(
             simulation_runs,
-            np.array(full_filled_real_prices),
+            np.array(real_prices),
             time_increment,
         )
     except Exception as e: