Implemented initial Bayesian Logic

Author: luis-gasparschroeder

benchmarks/_plotter_combined.py

@@ -1160,7 +1160,7 @@ def plot_cache_hit_latency_vs_size_comparison(
                 linewidth=3,
                 label=f"Static Trend: {z_static[0]:.6f}x + {z_static[1]:.6f}",
             )
-        except:  # noqa: E722
+        except Exception:
             pass
 
     # Fit dynamic trend line if enough points
@@ -1176,7 +1176,7 @@ def plot_cache_hit_latency_vs_size_comparison(
                 linewidth=3,
                 label=f"Dynamic Trend: {z_dynamic[0]:.6f}x + {z_dynamic[1]:.6f}",
             )
-        except:  # noqa: E722
+        except Exception:  # Replace bare except
             pass
 
     plt.xlabel("Cache Size (MB)")

benchmarks/_plotter_individual.py

@@ -1,14 +1,24 @@
 import os
+from typing import TYPE_CHECKING
 
 import matplotlib.pyplot as plt
 import numpy as np
 import seaborn as sns
 from matplotlib.patches import Patch
 
-from .benchmark import Benchmark
+from vectorq.vectorq_core.cache.embedding_store.embedding_metadata_storage.embedding_metadata_obj import (
+    EmbeddingMetadataObj,
+)
+from vectorq.vectorq_core.vectorq_policy.strategies.bayesian import (
+    VectorQBayesianPolicy,
+)
 
+# Use TYPE_CHECKING to avoid circular imports
+if TYPE_CHECKING:
+    from benchmarks.benchmark import Benchmark
 
-def plot_error_rate_relative(benchmark: Benchmark, FONT_SIZE=20):
+
+def plot_error_rate_relative(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
     plt.plot(
@@ -42,7 +52,7 @@ def plot_error_rate_relative(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_error_rate_absolute(benchmark: Benchmark, FONT_SIZE=20):
+def plot_error_rate_absolute(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
     plt.plot(benchmark.sample_sizes, benchmark.error_rates_absolute, color="blue")
@@ -69,7 +79,7 @@ def plot_error_rate_absolute(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_relative_error_rate_step_size_(benchmark: Benchmark, FONT_SIZE=20):
+def plot_relative_error_rate_step_size_(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
     plt.plot(
@@ -101,7 +111,7 @@ def plot_relative_error_rate_step_size_(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_reuse_rate(benchmark: Benchmark, FONT_SIZE=20):
+def plot_reuse_rate(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     reuse_rates = [
         (reused / size * 100) if size > 0 else 0
@@ -133,7 +143,7 @@ def plot_reuse_rate(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_relative_reuse_rate(benchmark: Benchmark, FONT_SIZE=20):
+def plot_relative_reuse_rate(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
     plt.plot(benchmark.sample_sizes, benchmark.relative_reuse_rates, color="blue")
@@ -161,7 +171,7 @@ def plot_relative_reuse_rate(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_duration_step_size(benchmark: Benchmark, FONT_SIZE=20):
+def plot_duration_step_size(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
     plt.plot(
@@ -190,7 +200,7 @@ def plot_duration_step_size(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_duration_trend(benchmark: Benchmark, FONT_SIZE=20):
+def plot_duration_trend(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
     # Convert seconds to minutes
@@ -221,7 +231,7 @@ def plot_duration_trend(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_precision(benchmark: Benchmark, FONT_SIZE=20):
+def plot_precision(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
     plt.plot(benchmark.sample_sizes, benchmark.precision_list, color="blue")
@@ -237,7 +247,7 @@ def plot_precision(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_recall(benchmark: Benchmark, FONT_SIZE=20):
+def plot_recall(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
     plt.plot(benchmark.sample_sizes, benchmark.recall_list, color="blue")
@@ -253,7 +263,7 @@ def plot_recall(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_accuracy(benchmark: Benchmark, FONT_SIZE=20):
+def plot_accuracy(benchmark: "Benchmark", FONT_SIZE=20):
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
     plt.plot(benchmark.sample_sizes, benchmark.accuracy_list, color="blue")
@@ -269,7 +279,7 @@ def plot_accuracy(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def plot_cache_size(benchmark: Benchmark, FONT_SIZE=20):
+def plot_cache_size(benchmark: "Benchmark", FONT_SIZE=20):
     """Plot cache size growth as samples are processed."""
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
@@ -283,7 +293,7 @@ def plot_cache_size(benchmark: Benchmark, FONT_SIZE=20):
     plt.close()
 
 
-def add_description(benchmark: Benchmark, plt):
+def add_description(benchmark: "Benchmark", plt):
     if benchmark.is_dynamic_threshold:
         description = (
             f"VectorQ, rnd_num_ub: {benchmark.rnd_num_ub}, Data Source: {os.path.basename(benchmark.filepath)}\n"
@@ -311,7 +321,7 @@ def add_description(benchmark: Benchmark, plt):
     )
 
 
-def plot_cache_hit_latency_vs_size(benchmark: Benchmark, FONT_SIZE=20):
+def plot_cache_hit_latency_vs_size(benchmark: "Benchmark", FONT_SIZE=20):
     cache_sizes = []
     hit_latencies = []
     cache_hits_count = []  # Track the cumulative number of cache hits
@@ -328,27 +338,18 @@ def plot_cache_hit_latency_vs_size(benchmark: Benchmark, FONT_SIZE=20):
         print("Not enough cache hits to plot cache hit latency vs cache size")
         return
 
-    # Remove outliers using IQR method
     latencies_array = np.array(hit_latencies)
     q1 = np.percentile(latencies_array, 25)
     q3 = np.percentile(latencies_array, 75)
     iqr = q3 - q1
     lower_bound = q1 - 1.5 * iqr
     upper_bound = q3 + 1.5 * iqr
 
-    # Filter out outliers
     outlier_mask = (latencies_array >= lower_bound) & (latencies_array <= upper_bound)
     filtered_cache_sizes = np.array(cache_sizes)[outlier_mask]
     filtered_hit_latencies = latencies_array[outlier_mask]
     filtered_cache_hits_count = np.array(cache_hits_count)[outlier_mask]
 
-    # Print how many outliers were removed
-    num_outliers = len(hit_latencies) - len(filtered_hit_latencies)
-    if num_outliers > 0:
-        print(
-            f"Removed {num_outliers} outliers from hit latencies (out of {len(hit_latencies)})"
-        )
-
     plt.rcParams.update({"font.size": FONT_SIZE})
     plt.figure(figsize=(16, 7))
 
@@ -380,8 +381,7 @@ def plot_cache_hit_latency_vs_size(benchmark: Benchmark, FONT_SIZE=20):
                 label=f"Trend: {z[0]:.6f}x + {z[1]:.4f}",
                 linewidth=4,
             )
-        except:  # noqa: E722
-            # If fitting fails, just continue without the trend line
+        except Exception:
             pass
 
     ax1.set_xlabel("Cache Size (MB)")
@@ -434,7 +434,7 @@ def plot_cache_hit_latency_vs_size(benchmark: Benchmark, FONT_SIZE=20):
 
 
 # TODO: LGS
-def plot_combined_thresholds_and_posteriors(benchmark: Benchmark):
+def plot_combined_thresholds_and_posteriors(benchmark: "Benchmark"):
     for idx, correct_similarities, incorrect_similarities, posteriors in zip(
         benchmark.correct_x.keys(),
         benchmark.correct_x.values(),
@@ -514,3 +514,108 @@ def plot_combined_thresholds_and_posteriors(benchmark: Benchmark):
             os.makedirs(output_folder_path)
         plt.savefig(filename, format="pdf", bbox_inches="tight")
         plt.close()
+
+
+def plot_bayesian_decision_boundary(benchmark: "Benchmark"):
+    if benchmark.is_dynamic_threshold:
+        vectorQ = VectorQBayesianPolicy(delta=benchmark.delta)
+
+        for idx, observations, gamma in zip(
+            benchmark.observations.keys(),
+            benchmark.observations.values(),
+            benchmark.gammas,
+        ):
+            if len(observations) == 0:
+                continue
+
+            metadata = EmbeddingMetadataObj(embedding_id=-1, response="None")
+            metadata.gamma = gamma
+
+            similarities = np.array([obs[0] for obs in observations])
+            labels = np.array([obs[1] for obs in observations])
+            correct_obs = np.array([obs[0] for obs in observations if obs[1] == 1])
+            incorrect_obs = np.array([obs[0] for obs in observations if obs[1] == 0])
+
+            if (
+                len(similarities) < 15
+                or len(labels) < 15
+                or len(correct_obs) < 3
+                or len(incorrect_obs) < 3
+            ):
+                continue
+
+            t_hat = vectorQ._estimate_parameters(similarities, labels, metadata)
+
+            s_values = np.linspace(0.0, 1.0, 100)
+
+            # Calculate tau for each similarity value
+            tau_values = []
+            for s in s_values:
+                tau = vectorQ._get_tau(similarities, labels, s, t_hat, metadata)
+                tau_values.append(tau)
+
+            # Calculate probability for each similarity value
+            probs = [vectorQ._likelihood(s, t_hat, gamma) for s in s_values]
+
+            plt.figure(figsize=(12, 8))
+            plt.plot(
+                s_values,
+                tau_values,
+                "r-",
+                linewidth=2,
+                label="Tau (exploration probability)",
+            )
+            plt.plot(
+                s_values,
+                probs,
+                "b--",
+                linewidth=2,
+                label=f"Probability curve (γ={gamma})",
+            )
+            plt.axvline(
+                x=t_hat,
+                color="g",
+                linestyle="--",
+                label=f"Decision boundary (t_hat={t_hat:.2f})",
+            )
+
+            plt.scatter(
+                correct_obs,
+                [0.05] * len(correct_obs),
+                color="green",
+                label="Correct observations",
+                s=80,
+                alpha=0.7,
+            )
+            plt.scatter(
+                incorrect_obs,
+                [0.05] * len(incorrect_obs),
+                color="red",
+                label="Incorrect observations",
+                s=80,
+                alpha=0.7,
+            )
+
+            plt.xlim([0.0, 1.0])
+            plt.ylim([0, 1.05])
+            plt.xlabel("Similarity (s)", fontsize=18)
+            plt.ylabel("Probability / Tau", fontsize=18)
+            plt.title(
+                f"Exploration Probability (Tau) vs. Similarity (δ={vectorQ.delta})",
+                fontsize=18,
+            )
+            plt.grid(True, alpha=0.3)
+            plt.legend(fontsize=18)
+            plt.tight_layout(rect=[0, 0.05, 1, 1])
+
+            output_folder_path = (
+                benchmark.output_folder_path + "/bayesian_decision_boundary/"
+            )
+            filename = (
+                benchmark.output_folder_path
+                + f"/bayesian_decision_boundary/decision_boundary_embedding_{idx}_{benchmark.timestamp}.pdf"
+            )
+            if output_folder_path and not os.path.exists(output_folder_path):
+                os.makedirs(output_folder_path)
+            plt.savefig(filename, format="pdf", bbox_inches="tight")
+            plt.close()