orizu 0.5.19 → 0.5.21

package/vendor/gepa-python/src/gepa/logging/experiment_tracker.py

@@ -0,0 +1,457 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+from typing import Any
+
+
+class ExperimentTracker:
+    """
+    Unified experiment tracking that supports both wandb and mlflow.
+    """
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.initialize()
+        self.start_run()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - always end the run."""
+        self.end_run()
+        return False  # Don't suppress exceptions
+
+    def __init__(
+        self,
+        use_wandb: bool = False,
+        wandb_api_key: str | None = None,
+        wandb_init_kwargs: dict[str, Any] | None = None,
+        wandb_attach_existing: bool = False,
+        wandb_step_metric: str | None = None,
+        use_mlflow: bool = False,
+        mlflow_tracking_uri: str | None = None,
+        mlflow_experiment_name: str | None = None,
+        mlflow_attach_existing: bool = False,
+        key_prefix: str = "",
+    ):
+        self.use_wandb = use_wandb
+        self.use_mlflow = use_mlflow
+
+        self.wandb_api_key = wandb_api_key
+        self.wandb_init_kwargs = wandb_init_kwargs or {}
+        self.wandb_attach_existing = wandb_attach_existing
+        self.wandb_step_metric = wandb_step_metric
+        self.mlflow_tracking_uri = mlflow_tracking_uri
+        self.mlflow_experiment_name = mlflow_experiment_name
+        self.mlflow_attach_existing = mlflow_attach_existing
+        self.key_prefix = key_prefix
+
+        self._created_mlflow_run = False
+        self._mlflow_run_id: str | None = None
+        self._mlflow_client: Any = None
+        self._wandb_step_metric_defined = False
+
+        # Accumulate table rows so each wandb.log() sends the full growing
+        # table, not just the latest row.  Without this, commit=False causes
+        # the pending dict to overwrite earlier single-row tables with the
+        # newest one, and only the last row per commit cycle survives.
+        self._wandb_table_rows: dict[str, tuple[list[str], list[list]]] = {}
+
+    def _p(self, key: str) -> str:
+        """Prepend key_prefix to a key/name, if one is set."""
+        return f"{self.key_prefix}{key}" if self.key_prefix else key
+
+    def initialize(self):
+        """Initialize the logging backends."""
+        if self.use_wandb:
+            self._initialize_wandb()
+        if self.use_mlflow:
+            self._initialize_mlflow()
+
+    def _initialize_wandb(self):
+        """Initialize wandb."""
+        try:
+            import wandb  # type: ignore
+
+            if self.wandb_api_key:
+                wandb.login(key=self.wandb_api_key, verify=True)
+            else:
+                wandb.login()
+        except ImportError:
+            raise ImportError("wandb is not installed. Please install it or set backend='mlflow' or 'none'.")
+        except Exception as e:
+            raise RuntimeError(f"Error logging into wandb: {e}")
+
+    def _initialize_mlflow(self):
+        """Initialize mlflow."""
+        try:
+            import mlflow  # type: ignore
+
+            if self.mlflow_tracking_uri:
+                mlflow.set_tracking_uri(self.mlflow_tracking_uri)
+            if self.mlflow_experiment_name:
+                mlflow.set_experiment(self.mlflow_experiment_name)
+        except ImportError:
+            raise ImportError("mlflow is not installed. Please install it or set backend='wandb' or 'none'.")
+        except Exception as e:
+            raise RuntimeError(f"Error setting up mlflow: {e}")
+
+    def _define_wandb_step_metric(self) -> None:
+        """Declare a custom x-axis for all GEPA metrics in wandb.
+
+        Called once on the first ``log_metrics`` call (not in ``start_run``)
+        so that it works regardless of whether GEPA owns the ``wandb.init``
+        call or is attaching to an existing run.
+
+        When ``wandb_step_metric`` is set, all GEPA metrics are plotted
+        against this custom step metric instead of wandb's global monotonic
+        step counter.  This avoids conflicts when GEPA is embedded inside
+        a host training loop that uses its own step counter.
+        """
+        if self._wandb_step_metric_defined or not self.wandb_step_metric:
+            return
+        try:
+            import wandb  # type: ignore
+
+            if wandb.run is not None:
+                wandb.define_metric(self.wandb_step_metric, hidden=False)
+                # Scope the custom x-axis to GEPA's prefixed metrics only.
+                # Using "*" would override the x-axis for ALL metrics in the
+                # run, including the host's metrics (e.g. train/loss), causing
+                # wandb to drop the host's data after GEPA runs.
+                if self.key_prefix:
+                    glob = f"{self.key_prefix}*"
+                else:
+                    glob = "*"
+                wandb.define_metric(glob, step_metric=self.wandb_step_metric)
+                self._wandb_step_metric_defined = True
+        except Exception as e:
+            print(f"Warning: Failed to define wandb step metric: {e}")
+
+    def start_run(self):
+        """Start a new run.
+
+        When ``wandb_attach_existing=True`` the tracker skips ``wandb.init()``
+        and logs into whatever run is already active in the process.
+        When ``mlflow_attach_existing=True`` the tracker skips
+        ``mlflow.start_run()`` and logs into the already-active MLflow run.
+        In both cases ``end_run()`` will not terminate the run.
+        """
+        if self.use_wandb:
+            if self.wandb_attach_existing:
+                # Attach to the active run — no init, no finish later.
+                pass
+            else:
+                import wandb  # type: ignore
+
+                wandb.init(**self.wandb_init_kwargs)
+        if self.use_mlflow:
+            import mlflow  # type: ignore
+            from mlflow import MlflowClient  # type: ignore
+
+            if self.mlflow_attach_existing:
+                # Attach to the active run — no start, no end later.
+                self._created_mlflow_run = False
+            else:
+                # Only start a new run if there's no active run
+                if mlflow.active_run() is None:
+                    mlflow.start_run()
+                    self._created_mlflow_run = True
+                else:
+                    self._created_mlflow_run = False
+
+            # Capture run_id and create a client for thread-safe logging.
+            # mlflow.active_run() is thread-local, so parallel threads
+            # (e.g. parallel proposals) would auto-create new runs without this.
+            active = mlflow.active_run()
+            if active is not None:
+                self._mlflow_run_id = active.info.run_id
+                try:
+                    tracking_uri = mlflow.get_tracking_uri()
+                    self._mlflow_client = MlflowClient(tracking_uri=tracking_uri)
+                except Exception:
+                    # MlflowClient creation can fail in test environments;
+                    # fall back to fluent API (thread-unsafe but functional).
+                    self._mlflow_client = None
+
+    def log_config(self, config: dict[str, Any]) -> None:
+        """Log run configuration/hyperparameters to the active backends.
+
+        Args:
+            config: Flat dict of config key-value pairs. Non-serializable values
+                    are converted to strings.
+        """
+        safe_config = {}
+        for k, v in config.items():
+            if isinstance(v, bool | int | float | str | type(None)):
+                safe_config[k] = v
+            else:
+                safe_config[k] = str(v)
+
+        if self.use_wandb:
+            try:
+                import wandb  # type: ignore
+
+                prefixed = {self._p(k): v for k, v in safe_config.items()}
+                wandb.config.update(prefixed, allow_val_change=True)
+            except Exception as e:
+                print(f"Warning: Failed to log config to wandb: {e}")
+
+        if self.use_mlflow:
+            try:
+                str_params = {self._p(k): str(v) for k, v in safe_config.items()}
+                if self._mlflow_client and self._mlflow_run_id:
+                    for k, v in str_params.items():
+                        self._mlflow_client.log_param(self._mlflow_run_id, k, v)
+                else:
+                    import mlflow  # type: ignore
+                    mlflow.log_params(str_params)
+            except Exception as e:
+                print(f"Warning: Failed to log config to mlflow: {e}")
+
+    def log_metrics(self, metrics: dict[str, Any], step: int | None = None):
+        """Log metrics to the active backends."""
+        if self.use_wandb:
+            try:
+                import wandb  # type: ignore
+
+                # Lazily define the custom step metric on the first log call.
+                self._define_wandb_step_metric()
+
+                # Filter to numeric values only — non-numeric data (dicts, strings)
+                # is logged via log_table() instead to avoid noisy flat charts
+                numeric_metrics = {self._p(k): v for k, v in metrics.items() if isinstance(v, int | float)}
+                if numeric_metrics:
+                    if self.wandb_step_metric and step is not None:
+                        # Use custom x-axis: inject the step as a metric value
+                        # and omit the step= arg to avoid conflicting with the
+                        # host run's global step counter.
+                        numeric_metrics[self.wandb_step_metric] = step
+                        wandb.log(numeric_metrics)
+                    else:
+                        wandb.log(numeric_metrics, step=step)
+            except Exception as e:
+                print(f"Warning: Failed to log to wandb: {e}")
+
+        if self.use_mlflow:
+            try:
+                numeric_metrics = {self._p(k): float(v) for k, v in metrics.items() if isinstance(v, int | float)}
+                if numeric_metrics:
+                    if self._mlflow_client and self._mlflow_run_id:
+                        for k, v in numeric_metrics.items():
+                            self._mlflow_client.log_metric(self._mlflow_run_id, k, v, step=step or 0)
+                    else:
+                        import mlflow  # type: ignore
+                        mlflow.log_metrics(numeric_metrics, step=step)
+            except Exception as e:
+                print(f"Warning: Failed to log to mlflow: {e}")
+
+    def log_summary(self, summary: dict[str, Any]) -> None:
+        """Log run summary data (visible on the run overview page).
+
+        Args:
+            summary: Key-value pairs for the run summary. Supports strings,
+                     numbers, and other serializable values.
+        """
+        if self.use_wandb:
+            try:
+                import wandb  # type: ignore
+
+                for k, v in summary.items():
+                    wandb.run.summary[self._p(k)] = v  # type: ignore[union-attr]
+            except Exception as e:
+                print(f"Warning: Failed to log summary to wandb: {e}")
+
+        if self.use_mlflow:
+            try:
+                numeric = {self._p(k): float(v) for k, v in summary.items() if isinstance(v, int | float)}
+                text = {self._p(k): str(v) for k, v in summary.items() if isinstance(v, str)}
+                if self._mlflow_client and self._mlflow_run_id:
+                    if numeric:
+                        for k, v in numeric.items():
+                            self._mlflow_client.log_metric(self._mlflow_run_id, k, v)
+                    if text:
+                        for k, v in text.items():
+                            self._mlflow_client.log_param(self._mlflow_run_id, f"summary/{k}", v)
+                else:
+                    import mlflow  # type: ignore
+                    if numeric:
+                        mlflow.log_metrics(numeric)
+                    if text:
+                        mlflow.log_params({f"summary/{k}": v for k, v in text.items()})
+            except Exception as e:
+                print(f"Warning: Failed to log summary to mlflow: {e}")
+
+    def log_table(self, table_name: str, columns: list[str], data: list[list[Any]]) -> None:
+        """Log a table to the active backends.
+
+        Args:
+            table_name: Name/key for the table.
+            columns: Column headers.
+            data: Rows of data (each row is a list matching columns).
+        """
+        if self.use_wandb:
+            try:
+                import wandb  # type: ignore
+
+                # Accumulate rows: each call appends to the stored rows for
+                # this table, then logs the full growing table.  This ensures
+                # all rows survive even when multiple log_table calls share
+                # the same commit cycle (commit=False overwrites the pending
+                # dict, so a single-row table would replace the previous one).
+                key = self._p(table_name)
+                if key not in self._wandb_table_rows:
+                    self._wandb_table_rows[key] = (columns, list(data))
+                else:
+                    self._wandb_table_rows[key][1].extend(data)
+                all_columns, all_rows = self._wandb_table_rows[key]
+                table = wandb.Table(columns=all_columns, data=all_rows)
+                wandb.log({key: table}, commit=False)
+            except Exception as e:
+                print(f"Warning: Failed to log table to wandb: {e}")
+
+        if self.use_mlflow:
+            try:
+                import mlflow  # type: ignore
+
+                if self._mlflow_run_id:
+                    # When we have a run_id, only log from the owning thread to avoid creating new runs
+                    active = mlflow.active_run()
+                    if active is None or active.info.run_id != self._mlflow_run_id:
+                        return
+                table_dict = {col: [row[i] for row in data] for i, col in enumerate(columns)}
+                mlflow.log_table(data=table_dict, artifact_file=f"{self._p(table_name)}.json")
+            except Exception as e:
+                print(f"Warning: Failed to log table to mlflow: {e}")
+
+    def log_html(self, html_content: str, key: str = "candidate_tree") -> None:
+        """Log an HTML string as a rich media artifact.
+
+        Args:
+            html_content: Self-contained HTML string.
+            key: Artifact key / name used in the dashboard.
+        """
+        if self.use_wandb:
+            try:
+                import wandb  # type: ignore
+
+                html_obj = wandb.Html(html_content)
+                pkey = self._p(key)
+                wandb.log({pkey: html_obj}, commit=False)
+                # Also write to run summary so the panel always shows the latest tree
+                wandb.run.summary[pkey] = html_obj  # type: ignore[union-attr]
+            except Exception as e:
+                print(f"Warning: Failed to log HTML to wandb: {e}")
+
+        if self.use_mlflow:
+            try:
+                import tempfile
+
+                with tempfile.NamedTemporaryFile(mode="w", suffix=".html", delete=False) as f:
+                    f.write(html_content)
+                    tmp_path = f.name
+                if self._mlflow_client and self._mlflow_run_id:
+                    self._mlflow_client.log_artifact(self._mlflow_run_id, tmp_path, artifact_path=self._p(key))
+                else:
+                    import mlflow  # type: ignore
+                    mlflow.log_artifact(tmp_path, artifact_path=self._p(key))
+            except Exception as e:
+                print(f"Warning: Failed to log HTML to mlflow: {e}")
+
+    def end_run(self):
+        """End the current run.
+
+        When ``wandb_attach_existing=True`` or ``mlflow_attach_existing=True``
+        the respective run is left open — the caller owns its lifecycle.
+        """
+        if self.use_wandb and not self.wandb_attach_existing:
+            try:
+                import wandb  # type: ignore
+
+                if wandb.run is not None:
+                    wandb.finish()
+            except Exception as e:
+                print(f"Warning: Failed to end wandb run: {e}")
+
+        if self.use_mlflow:
+            try:
+                import mlflow  # type: ignore
+
+                if self._created_mlflow_run and mlflow.active_run() is not None:
+                    mlflow.end_run()
+                    self._created_mlflow_run = False
+            except Exception as e:
+                print(f"Warning: Failed to end mlflow run: {e}")
+
+    def is_active(self) -> bool:
+        """Check if any backend has an active run."""
+        if self.use_wandb:
+            try:
+                import wandb  # type: ignore
+
+                if wandb.run is not None:
+                    return True
+            except Exception:
+                pass
+
+        if self.use_mlflow:
+            try:
+                import mlflow  # type: ignore
+
+                if mlflow.active_run() is not None:
+                    return True
+            except Exception:
+                pass
+
+        return False
+
+
+def create_experiment_tracker(
+    use_wandb: bool = False,
+    wandb_api_key: str | None = None,
+    wandb_init_kwargs: dict[str, Any] | None = None,
+    wandb_attach_existing: bool = False,
+    wandb_step_metric: str | None = None,
+    use_mlflow: bool = False,
+    mlflow_tracking_uri: str | None = None,
+    mlflow_experiment_name: str | None = None,
+    mlflow_attach_existing: bool = False,
+    key_prefix: str = "",
+) -> ExperimentTracker:
+    """
+    Create an experiment tracker based on the specified backends.
+
+    Args:
+        use_wandb: Whether to use wandb
+        use_mlflow: Whether to use mlflow
+        wandb_api_key: API key for wandb
+        wandb_init_kwargs: Additional kwargs for wandb.init()
+        wandb_attach_existing: When True, skip wandb.init() and wandb.finish()
+            and log into the already-active run.
+        wandb_step_metric: Custom x-axis metric name for wandb.  When set,
+            GEPA uses ``wandb.define_metric`` to log all metrics against this
+            custom step instead of wandb's global monotonic step counter.
+            Required when embedding GEPA inside a host training loop that
+            manages its own wandb step counter.
+        mlflow_tracking_uri: Tracking URI for mlflow
+        mlflow_experiment_name: Experiment name for mlflow
+        mlflow_attach_existing: When True, skip mlflow.start_run() and
+            mlflow.end_run() and log into the already-active run.
+
+    Returns:
+        ExperimentTracker instance
+
+    Note:
+        Both wandb and mlflow can be used simultaneously if desired.
+    """
+    return ExperimentTracker(
+        use_wandb=use_wandb,
+        wandb_api_key=wandb_api_key,
+        wandb_init_kwargs=wandb_init_kwargs,
+        wandb_attach_existing=wandb_attach_existing,
+        wandb_step_metric=wandb_step_metric,
+        use_mlflow=use_mlflow,
+        mlflow_tracking_uri=mlflow_tracking_uri,
+        mlflow_experiment_name=mlflow_experiment_name,
+        mlflow_attach_existing=mlflow_attach_existing,
+        key_prefix=key_prefix,
+    )

package/vendor/gepa-python/src/gepa/logging/logger.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+import sys
+from typing import Protocol
+
+
+class LoggerProtocol(Protocol):
+    def log(self, message: str): ...
+
+
+class StdOutLogger(LoggerProtocol):
+    def log(self, message: str):
+        print(message)
+
+
+class Tee:
+    def __init__(self, *files):
+        self.files = files
+
+    def write(self, obj):
+        for f in self.files:
+            f.write(obj)
+
+    def flush(self):
+        for f in self.files:
+            if hasattr(f, "flush"):
+                f.flush()
+
+    def isatty(self):
+        # True if any of the files is a terminal
+        return any(hasattr(f, "isatty") and f.isatty() for f in self.files)
+
+    def close(self):
+        for f in self.files:
+            if hasattr(f, "close"):
+                f.close()
+
+    def fileno(self):
+        for f in self.files:
+            if hasattr(f, "fileno"):
+                return f.fileno()
+        raise OSError("No underlying file object with fileno")
+
+
+class Logger(LoggerProtocol):
+    def __init__(self, filename, mode="a"):
+        self.file_handle = open(filename, mode)
+        self.file_handle_stderr = open(filename.replace("run_log.", "run_log_stderr."), mode)
+        self.modified_sys = False
+
+    def __enter__(self):
+        self.original_stdout = sys.stdout
+        self.original_stderr = sys.stderr
+        sys.stdout = Tee(sys.stdout, self.file_handle)
+        sys.stderr = Tee(sys.stderr, self.file_handle_stderr)
+        self.modified_sys = True
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        sys.stdout = self.original_stdout
+        sys.stderr = self.original_stderr
+        self.file_handle.close()
+        self.file_handle_stderr.close()
+        self.modified_sys = False
+
+    def log(self, *args, **kwargs):
+        if self.modified_sys:
+            print(*args, **kwargs)
+        else:
+            # Emulate print(*args, **kwargs) behavior but write to the file
+            print(*args, **kwargs)
+            print(*args, file=self.file_handle_stderr, **kwargs)
+        self.file_handle.flush()
+        self.file_handle_stderr.flush()

package/vendor/gepa-python/src/gepa/logging/utils.py

@@ -0,0 +1,130 @@
+# Copyright (c) 2025 Lakshya A Agrawal and the GEPA contributors
+# https://github.com/gepa-ai/gepa
+
+
+from gepa.core.adapter import DataInst
+from gepa.core.data_loader import DataId
+from gepa.core.state import GEPAState, ValsetEvaluation
+from gepa.strategies.eval_policy import EvaluationPolicy
+
+
+def log_detailed_metrics_after_discovering_new_program(
+    logger,
+    gepa_state: GEPAState,
+    new_program_idx,
+    valset_evaluation: ValsetEvaluation,
+    objective_scores,
+    experiment_tracker,
+    linear_pareto_front_program_idx,
+    valset_size: int,
+    val_evaluation_policy: EvaluationPolicy[DataId, DataInst],
+):
+    # best_prog_per_agg_val_score = idxmax(gepa_state.program_full_scores_val_set)
+    best_prog_per_agg_val_score = val_evaluation_policy.get_best_program(gepa_state)
+    best_score_on_valset = val_evaluation_policy.get_valset_score(best_prog_per_agg_val_score, gepa_state)
+
+    # avg, coverage = gepa_state.get_program_average_val_subset(new_program_idx)
+    valset_score = val_evaluation_policy.get_valset_score(new_program_idx, gepa_state)
+    valset_scores = valset_evaluation.scores_by_val_id
+    coverage = len(valset_scores)
+    logger.log(
+        f"Iteration {gepa_state.i + 1}: Valset score for new program: {valset_score}"
+        f" (coverage {coverage} / {valset_size})"
+    )
+
+    agg_valset_score_new_program = val_evaluation_policy.get_valset_score(new_program_idx, gepa_state)
+
+    logger.log(f"Iteration {gepa_state.i + 1}: Val aggregate for new program: {agg_valset_score_new_program}")
+    logger.log(f"Iteration {gepa_state.i + 1}: Individual valset scores for new program: {valset_scores}")
+    if objective_scores:
+        logger.log(f"Iteration {gepa_state.i + 1}: Objective aggregate scores for new program: {objective_scores}")
+    logger.log(f"Iteration {gepa_state.i + 1}: New valset pareto front scores: {gepa_state.pareto_front_valset}")
+    if gepa_state.objective_pareto_front:
+        logger.log(f"Iteration {gepa_state.i + 1}: Objective pareto front scores: {gepa_state.objective_pareto_front}")
+
+    pareto_scores = list(gepa_state.pareto_front_valset.values())
+    assert all(score > float("-inf") for score in pareto_scores), (
+        "Should have at least one valid score per validation example"
+    )
+    assert len(pareto_scores) > 0
+    pareto_avg = sum(pareto_scores) / len(pareto_scores)
+
+    logger.log(f"Iteration {gepa_state.i + 1}: Valset pareto front aggregate score: {pareto_avg}")
+    logger.log(
+        f"Iteration {gepa_state.i + 1}: Updated valset pareto front programs: {gepa_state.program_at_pareto_front_valset}"
+    )
+    if gepa_state.program_at_pareto_front_objectives:
+        logger.log(
+            f"Iteration {gepa_state.i + 1}: Updated objective pareto front programs: {gepa_state.program_at_pareto_front_objectives}"
+        )
+    logger.log(
+        f"Iteration {gepa_state.i + 1}: Best valset aggregate score so far: {max(gepa_state.program_full_scores_val_set)}"
+    )
+    logger.log(
+        f"Iteration {gepa_state.i + 1}: Best program as per aggregate score on valset: {best_prog_per_agg_val_score}"
+    )
+    logger.log(f"Iteration {gepa_state.i + 1}: Best score on valset: {best_score_on_valset}")
+    logger.log(f"Iteration {gepa_state.i + 1}: Linear pareto front program index: {linear_pareto_front_program_idx}")
+    logger.log(f"Iteration {gepa_state.i + 1}: New program candidate index: {new_program_idx}")
+
+    # Scalar metrics go to log_metrics (creates wandb/mlflow line charts)
+    metrics = {
+        "iteration": gepa_state.i + 1,
+        "new_program_idx": new_program_idx,
+        "valset_pareto_front_agg": pareto_avg,
+        "best_score_on_valset": best_score_on_valset,
+        "linear_pareto_front_program_idx": linear_pareto_front_program_idx,
+        "best_program_as_per_agg_score_valset": best_prog_per_agg_val_score,
+        "val_evaluated_count_new_program": coverage,
+        "val_total_count": valset_size,
+        "val_program_average": valset_score,
+        "total_metric_calls": gepa_state.total_num_evals,
+    }
+    if objective_scores:
+        for obj_name, obj_val in objective_scores.items():
+            if isinstance(obj_val, int | float):
+                metrics[f"objective/{obj_name}"] = obj_val
+    experiment_tracker.log_metrics(metrics, step=gepa_state.i + 1)
+
+    # Structured data goes to log_table (creates wandb Tables / mlflow artifacts)
+    # instead of log_metrics, which would flatten nested dicts into hundreds of charts.
+    # Only log the new candidate's row to avoid O(candidates * valset) repeated uploads.
+
+    all_val_ids = sorted(gepa_state.pareto_front_valset.keys(), key=str)
+    val_columns = ["candidate_idx", "parent_ids"] + [str(vid) for vid in all_val_ids]
+    new_scores_dict = gepa_state.prog_candidate_val_subscores[new_program_idx]
+    new_parent = gepa_state.parent_program_for_candidate[new_program_idx]
+    val_row = [new_program_idx, str(new_parent)] + [new_scores_dict.get(vid) for vid in all_val_ids]
+    experiment_tracker.log_table("valset_scores", columns=val_columns, data=[val_row])
+
+    # Valset pareto front: which programs are best for which val examples
+    pareto_front_rows = [
+        [str(val_id), score, str(sorted(gepa_state.program_at_pareto_front_valset[val_id]))]
+        for val_id, score in gepa_state.pareto_front_valset.items()
+    ]
+    if pareto_front_rows:
+        experiment_tracker.log_table(
+            "valset_pareto_front",
+            columns=["val_id", "best_score", "program_ids"],
+            data=pareto_front_rows,
+        )
+
+    # Objective scores for the new candidate only
+    new_obj_scores = gepa_state.prog_candidate_objective_scores[new_program_idx]
+    if new_obj_scores:
+        all_objectives = sorted(new_obj_scores.keys(), key=str)
+        obj_columns = ["candidate_idx", "parent_ids"] + [str(obj) for obj in all_objectives]
+        obj_row = [new_program_idx, str(new_parent)] + [new_obj_scores.get(obj) for obj in all_objectives]
+        experiment_tracker.log_table("objective_scores", columns=obj_columns, data=[obj_row])
+
+    # Objective pareto front
+    if gepa_state.objective_pareto_front:
+        obj_pareto_rows = [
+            [str(obj), float(score), str(sorted(gepa_state.program_at_pareto_front_objectives[obj]))]
+            for obj, score in gepa_state.objective_pareto_front.items()
+        ]
+        experiment_tracker.log_table(
+            "objective_pareto_front",
+            columns=["objective", "best_score", "program_ids"],
+            data=obj_pareto_rows,
+        )