Fixed epsilon grid

Author: luis-gasparschroeder

benchmarks/benchmark.py

@@ -48,7 +48,7 @@
 ########################################################################################################################
 
 # Benchmark Config
-MAX_SAMPLES: int = 45000
+MAX_SAMPLES: int = 10000
 CONFIDENCE_INTERVALS_ITERATIONS: int = 1
 EMBEDDING_MODEL_1 = (
     "embedding_1",

vectorq/vectorq_core/vectorq_policy/strategies/bayesian.py

@@ -20,7 +20,7 @@ class VectorQBayesianPolicy(VectorQPolicy):
     def __init__(self, delta: float, is_global: bool = False):
         self.delta: float = delta
         self.P_c: float = 1.0 - self.delta
-        self.epsilon_grid: np.ndarray = np.linspace(0.01, 0.5, 50)
+        self.epsilon_grid: np.ndarray = np.linspace(1e-6, 1-1e-6, 50)
         self.logistic_regression: LogisticRegression = LogisticRegression(
             penalty=None, solver="lbfgs", tol=1e-8, max_iter=1000, fit_intercept=False
         )
@@ -33,7 +33,7 @@ def __init__(self, delta: float, is_global: bool = False):
         self.global_t_hat: float = None
 
         self.variance_map: Dict[int, List[float]] = {
-            6: 0.002445,
+            6: 0.012445,
             7: 0.014285,
             8: 0.014436,
             9: 0.011349,
@@ -125,18 +125,18 @@ def select_action(
         if len(similarities) < 6 or len(labels) < 6:
             return Action.EXPLORE
 
-        start_time = time.time()
+        #start_time = time.time()
         t_hat, gamma, var_t = self._estimate_parameters(
             similarities=similarities, labels=labels
         )
-        end_time_parameter_estimation = time.time()
-        if self.is_global:
-            sorted_observations = sorted(self.global_observations, key=lambda x: x[0])
-        else:
-            sorted_observations = sorted(metadata.observations, key=lambda x: x[0])
-        logging.info(
-            f"Embedding {metadata.embedding_id} | similarity: {similarity_score} | Observations: {sorted_observations}"
-        )
+        #end_time_parameter_estimation = time.time()
+        #if self.is_global:
+        #    sorted_observations = sorted(self.global_observations, key=lambda x: x[0])
+        #else:
+        #    sorted_observations = sorted(metadata.observations, key=lambda x: x[0])
+        #logging.info(
+        #    f"Embedding {metadata.embedding_id} | similarity: {similarity_score} | Observations: {sorted_observations}"
+        #)
         if t_hat == -1:
             return Action.EXPLORE
         if self.is_global:
@@ -146,14 +146,14 @@ def select_action(
             metadata.gamma = gamma
             metadata.t_hat = t_hat
 
-        start_time = time.time()
+        #start_time = time.time()
         tau: float = self._get_tau(
             var_t=var_t, s=similarity_score, t_hat=t_hat, metadata=metadata
         )
-        logging.info(f"t_hat: {t_hat}, gamma: {gamma}, tau: {tau}")
-        logging.info(
-            f"Parameter estimation: {(end_time_parameter_estimation - start_time):.4f} sec, Tau estimation: {(time.time() - end_time_parameter_estimation):.4f} sec\n"
-        )
+        #logging.info(f"t_hat: {t_hat}, gamma: {gamma}, tau: {tau}")
+        #logging.info(
+        #    f"Parameter estimation: {(end_time_parameter_estimation - start_time):.4f} sec, Tau estimation: {(time.time() - end_time_parameter_estimation):.4f} sec\n"
+        #)
 
         u: float = random.uniform(0, 1)
         if u <= tau:
@@ -186,7 +186,6 @@ def _estimate_parameters(
 
             t_hat = -intercept / (gamma + 1e-6)
             t_hat = float(np.clip(t_hat, 0.0, 1.0))
-            # gamma = float(max(12.0, gamma))
 
             similarities_col = (
                 similarities[:, 1] if similarities.shape[1] > 1 else similarities[:, 0]
@@ -202,7 +201,7 @@ def _estimate_parameters(
                 intercept=intercept,
             )
 
-            return round(t_hat, 3), round(gamma, 3), round(var_t, 5)
+            return round(t_hat, 3), round(gamma, 3), var_t
 
         except Exception as e:
             print(f"Logistic regression failed: {e}")
@@ -236,7 +235,7 @@ def _get_var_t(
             else:
                 max_observations = max(self.variance_map.keys())
                 var_t = self.variance_map[max_observations]
-            logging.info(f"var_t (map): {round(var_t, 5)}")
+            #logging.info(f"var_t (map): {round(var_t, 5)}")
             return var_t
         else:
             p = self.logistic_regression.predict_proba(X)[:, 1]
@@ -249,7 +248,7 @@ def _get_var_t(
 
             var_t_hat = float(grad @ cov_beta @ grad)
             var_t_hat = max(0.0, var_t_hat)
-            logging.info(f"var_t_hat (delta method): {round(var_t_hat, 5)}")
+            #logging.info(f"var_t_hat (delta method): {round(var_t_hat, 5)}")
             return var_t_hat
 
     def _get_tau(
@@ -275,9 +274,9 @@ def _get_tau(
         else:
             likelihoods = self._likelihood(s=s, t=t_primes, gamma=metadata.gamma)
         alpha_lower_bounds = (1 - self.epsilon_grid) * likelihoods
-        logging.info(f"alpha_lower_bounds: {alpha_lower_bounds}")
+        #logging.info(f"alpha_lower_bounds: {alpha_lower_bounds}")
         taus = 1 - (1 - self.P_c) / (1 - alpha_lower_bounds)
-        return round(np.min(taus), 3)
+        return round(np.min(taus), 5)
 
     def _get_t_primes(self, t_hat: float, var_t: float) -> List[float]:
         """
@@ -296,7 +295,7 @@ def _get_t_primes(self, t_hat: float, var_t: float) -> List[float]:
                 for i in range(len(self.epsilon_grid))
             ]
         )
-        logging.info(f"t_primes: {t_primes}")
+        #logging.info(f"t_primes: {t_primes}")
         return t_primes
 
     def _confidence_interval(
@@ -314,7 +313,7 @@ def _confidence_interval(
         """
         z = norm.ppf(quantile)
         t_prime = t_hat + z * np.sqrt(var_t)
-        return round(float(np.clip(t_prime, 0.0, 1.0)), 3)
+        return float(np.clip(t_prime, 0.0, 1.0))
 
     def _likelihood(self, s: float, t: float, gamma: float) -> float:
         """