Source code for romtools.workflows.inverse.vi.sample_reuse

"""Importance-sampling sample reuse for VI and MFVI.

This module implements an opt-in ABRIS-style reuse layer around ROMTools'
existing VI drivers. Expensive high-fidelity evaluations are cached in batches
together with the variational distribution that generated them.  A bounded
inner sampling loop adds fresh batches until the reuse diagnostics pass, then
forms the update from the complete retained archive.
"""

from __future__ import annotations

from dataclasses import dataclass
import inspect
import re
from typing import Optional

import numpy as np

from romtools.hpc.dispatchers import resolve_dispatcher, resolve_local_dispatcher
from romtools.workflows.inverse.vi import drivers as _vi
from romtools.workflows.inverse.vi import mf_drivers as _mf
from romtools.workflows.inverse.vi.optimization import _normalize_optimization_method


[docs] @dataclass(frozen=True) class VISampleReuseConfig: """Configuration for ABRIS-style reuse of previous VI samples. ``history_batches`` controls both the maximum moving-window size and the maximum number of fresh batches allowed in one state evaluation. During zero-based iteration ``i``, both limits grow as ``min(history_batches, i + 1)``. Every returned update is formed from the retained archive, including evaluations that sampled fresh batches. """ enabled: bool = True history_batches: int = 10 ess_threshold: Optional[float] = None use_score_diagnostic: bool = True score_error_scale: float = 1.0 periodic_refresh: Optional[int] = 100 use_hessian_score_diagnostic: bool = True hessian_score_error_scale: float = 2.0 hessian_relative_standard_error_threshold: Optional[float] = 0.25 def __post_init__(self): if self.history_batches < 1: raise ValueError("history_batches must be at least 1") if self.ess_threshold is not None and self.ess_threshold <= 0.0: raise ValueError("ess_threshold must be positive when provided") if not np.isfinite(self.score_error_scale) or self.score_error_scale < 0.0: raise ValueError("score_error_scale must be finite and non-negative") if self.periodic_refresh is not None and self.periodic_refresh < 1: raise ValueError("periodic_refresh must be at least 1 when provided") if ( not np.isfinite(self.hessian_score_error_scale) or self.hessian_score_error_scale < 0.0 ): raise ValueError( "hessian_score_error_scale must be finite and non-negative" ) threshold = self.hessian_relative_standard_error_threshold if threshold is not None and ( not np.isfinite(threshold) or threshold <= 0.0 ): raise ValueError( "hessian_relative_standard_error_threshold must be positive " "and finite when provided" )
@dataclass class _ReuseBatch: optimizer_samples: np.ndarray parameter_samples: np.ndarray qois: np.ndarray errors: np.ndarray variational_mean: np.ndarray variational_log_std: np.ndarray variational_correlation_cholesky: Optional[np.ndarray] iteration: int @property def size(self) -> int: return int(self.optimizer_samples.shape[0]) class _ReuseArchive: def __init__(self, config: VISampleReuseConfig): self.config = config self.optimization_method = "gradient" self.batches: list[_ReuseBatch] = [] def append(self, batch: _ReuseBatch, capacity: Optional[int] = None) -> None: self.batches.append(batch) retained = self.config.history_batches if capacity is None else int(capacity) if retained < 1: raise ValueError("archive capacity must be at least 1") if len(self.batches) > retained: self.batches = self.batches[-retained:] @property def sample_count(self) -> int: return sum(batch.size for batch in self.batches) def _iteration_from_path(path: str) -> int: match = re.search(r"iteration_(\d+)", str(path)) return 0 if match is None else int(match.group(1)) def _variational_std(log_std: np.ndarray) -> np.ndarray: return np.exp(np.asarray(log_std, dtype=float)) def _log_q(samples: np.ndarray, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky: Optional[np.ndarray]) -> np.ndarray: return _vi._compute_variational_log_densities( samples, np.asarray(mean, dtype=float), _variational_std(log_std), correlation_cholesky, ) def _logsumexp(values: np.ndarray, axis: int = 0) -> np.ndarray: maximum = np.max(values, axis=axis, keepdims=True) finite_maximum = np.where(np.isfinite(maximum), maximum, 0.0) shifted = values - finite_maximum result = finite_maximum + np.log(np.sum(np.exp(shifted), axis=axis, keepdims=True)) return np.squeeze(result, axis=axis) def _archive_arrays(archive: _ReuseArchive): optimizer_samples = np.vstack([batch.optimizer_samples for batch in archive.batches]) parameter_samples = np.vstack([batch.parameter_samples for batch in archive.batches]) qois = np.hstack([batch.qois for batch in archive.batches]) errors = np.hstack([batch.errors for batch in archive.batches]) return optimizer_samples, parameter_samples, qois, errors def _compute_importance_weights(archive: _ReuseArchive, current_mean: np.ndarray, current_log_std: np.ndarray, current_correlation_cholesky: Optional[np.ndarray]): samples, _, _, _ = _archive_arrays(archive) current_log_density = _log_q( samples, current_mean, current_log_std, current_correlation_cholesky ) batch_sizes = np.asarray([batch.size for batch in archive.batches], dtype=float) log_beta = np.log(batch_sizes / np.sum(batch_sizes)) component_logs = [] for beta, batch in zip(log_beta, archive.batches): component_logs.append( beta + _log_q( samples, batch.variational_mean, batch.variational_log_std, batch.variational_correlation_cholesky, ) ) mixture_log_density = _logsumexp(np.vstack(component_logs), axis=0) log_weights = current_log_density - mixture_log_density weights = np.exp(np.clip(log_weights, -50.0, 50.0)) origin_weights = np.empty(samples.shape[0], dtype=float) offset = 0 for batch in archive.batches: sl = slice(offset, offset + batch.size) origin_log_density = _log_q( samples[sl], batch.variational_mean, batch.variational_log_std, batch.variational_correlation_cholesky, ) log_origin_ratio = current_log_density[sl] - origin_log_density origin_weights[sl] = np.exp(np.clip(log_origin_ratio, -50.0, 50.0)) offset += batch.size return weights, origin_weights def _effective_sample_size(weights: np.ndarray) -> float: numerator = float(np.sum(weights)) ** 2 denominator = float(np.sum(np.asarray(weights) ** 2)) if denominator <= 0.0 or not np.isfinite(denominator): return 0.0 return numerator / denominator def _score_functions(samples: np.ndarray, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky: Optional[np.ndarray]): std = _variational_std(log_std) centered = samples - mean[None, :] normalized = centered / std[None, :] if correlation_cholesky is None: score_mean = centered / (std[None, :] ** 2) score_log_std = normalized ** 2 - 1.0 else: correlation_solve = np.linalg.solve( correlation_cholesky, normalized.transpose() ) inverse_times_normalized = np.linalg.solve( correlation_cholesky.transpose(), correlation_solve ).transpose() score_mean = inverse_times_normalized / std[None, :] score_log_std = normalized * inverse_times_normalized - 1.0 return score_mean, score_log_std def _draw_optimizer_only(mean: np.ndarray, log_std: np.ndarray, sample_count: int, correlation_cholesky: Optional[np.ndarray]): standard_normal = np.random.randn(sample_count, mean.size) if correlation_cholesky is not None: standard_normal = standard_normal @ correlation_cholesky.transpose() return mean[None, :] + _variational_std(log_std)[None, :] * standard_normal def _score_diagnostics(archive: _ReuseArchive, current_mean: np.ndarray, current_log_std: np.ndarray, current_correlation_cholesky: Optional[np.ndarray], weights: np.ndarray, reference_sample_count: int): samples, _, _, _ = _archive_arrays(archive) score_mean, score_log_std = _score_functions( samples, current_mean, current_log_std, current_correlation_cholesky ) recycled_error = np.mean( weights[:, None] * np.hstack([score_mean, score_log_std]), axis=0 ) reference_samples = _draw_optimizer_only( current_mean, current_log_std, reference_sample_count, current_correlation_cholesky, ) ref_mean, ref_log_std = _score_functions( reference_samples, current_mean, current_log_std, current_correlation_cholesky, ) reference_error = np.mean(np.hstack([ref_mean, ref_log_std]), axis=0) # The inverse Fisher metric for mean-field Gaussian parameters # (mean, log-standard-deviation) is diag(std**2, 1/2). metric_diagonal = np.concatenate([ _variational_std(current_log_std) ** 2, 0.5 * np.ones_like(current_log_std, dtype=float), ]) def metric_norm(error): return float(np.sqrt(np.sum(metric_diagonal * np.asarray(error) ** 2))) return metric_norm(recycled_error), metric_norm(reference_error) def _weighted_loo_baseline(values: np.ndarray, origin_weights: np.ndarray) -> np.ndarray: """Origin-proposal LOO baseline for a heterogeneous proposal archive.""" values = np.asarray(values, dtype=float) origin_weights = np.asarray(origin_weights, dtype=float) if values.size <= 1: return np.zeros_like(values) weighted_values = origin_weights * values return (np.sum(weighted_values) - weighted_values) / float(values.size - 1) def _gradient_from_archive(samples: np.ndarray, values: np.ndarray, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky: Optional[np.ndarray], importance_weights: np.ndarray, origin_weights: np.ndarray, baseline_method: str, elbo_scaling_factor: float, entropy_strategy: str): score_mean, score_log_std = _score_functions( samples, mean, log_std, correlation_cholesky ) gradient_values = np.asarray(values, dtype=float) if entropy_strategy == "joint": gradient_values = gradient_values - elbo_scaling_factor * _log_q( samples, mean, log_std, correlation_cholesky ) if baseline_method == "loo": centered = gradient_values - _weighted_loo_baseline( gradient_values, origin_weights ) elif baseline_method == "none": centered = gradient_values else: raise NotImplementedError( "Sample reuse currently supports baseline_method='none' or 'loo'." ) weighted_mean_terms = importance_weights[:, None] * centered[:, None] * score_mean weighted_log_std_terms = ( importance_weights[:, None] * centered[:, None] * score_log_std ) gradient_mean = np.mean(weighted_mean_terms, axis=0) gradient_log_std = np.mean(weighted_log_std_terms, axis=0) if entropy_strategy == "analytic": gradient_log_std += elbo_scaling_factor standard_error = np.concatenate([ _vi._compute_component_standard_error(weighted_mean_terms), _vi._compute_component_standard_error(weighted_log_std_terms), ]) snr = _vi._compute_gradient_signal_to_noise_ratio( np.concatenate([gradient_mean, gradient_log_std]), standard_error ) zeros = np.zeros_like(mean) return gradient_mean, gradient_log_std, zeros, zeros, snr, standard_error def _refresh_decision(archive: _ReuseArchive, current_mean: np.ndarray, current_log_std: np.ndarray, current_correlation_cholesky: Optional[np.ndarray], nominal_batch_size: int, periodic_due: bool = False): if not archive.batches: return True, ("empty",), None, np.nan weights, origin_weights = _compute_importance_weights( archive, current_mean, current_log_std, current_correlation_cholesky, ) if not np.all(np.isfinite(weights)) or np.sum(weights) <= 0.0: return True, ("nonfinite_weights",), (weights, origin_weights), 0.0 ess = _effective_sample_size(weights) threshold = ( float(nominal_batch_size) if archive.config.ess_threshold is None else float(archive.config.ess_threshold) ) reasons = [] if ess <= threshold: reasons.append("ess") if periodic_due: reasons.append("periodic") if archive.config.use_score_diagnostic: recycled_error, reference_error = _score_diagnostics( archive, current_mean, current_log_std, current_correlation_cholesky, weights, nominal_batch_size, ) reference_scale = max(reference_error, np.sqrt(np.finfo(float).eps)) if recycled_error > archive.config.score_error_scale * reference_scale: reasons.append("score") if reasons: return True, tuple(reasons), (weights, origin_weights), ess return False, (), (weights, origin_weights), ess def _iteration_archive_limit(config: VISampleReuseConfig, iteration: int) -> int: """Return the zero-based ABRIS moving-window and sampling-loop limit.""" return min(config.history_batches, max(int(iteration) + 1, 1)) def _annotate_reuse_state(state, archive: _ReuseArchive, ess: float, refresh_reasons, refresh_limit_reached: bool, diagnostics=None): reasons = tuple(refresh_reasons) state["sample_reuse_used"] = True state["sample_reuse_refreshed"] = bool(reasons) state["sample_reuse_refresh_count"] = len(reasons) state["sample_reuse_refresh_reasons"] = reasons state["sample_reuse_refresh_reason"] = reasons[-1] if reasons else "reuse" state["sample_reuse_refresh_limit_reached"] = bool(refresh_limit_reached) state["sample_reuse_final_update_used_archive"] = True state["sample_reuse_ess"] = float(ess) state["sample_reuse_archive_samples"] = archive.sample_count state["sample_reuse_archive_batches"] = len(archive.batches) if diagnostics: state.update(diagnostics) return state def _batch_from_vi_state(state, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky: Optional[np.ndarray], iteration: int) -> _ReuseBatch: return _ReuseBatch( optimizer_samples=np.asarray(state["optimizer_samples"]).copy(), parameter_samples=np.asarray(state["parameter_samples"]).copy(), qois=np.asarray(state["qois"]).copy(), errors=np.asarray(state["errors"]).copy(), variational_mean=np.asarray(mean).copy(), variational_log_std=np.asarray(log_std).copy(), variational_correlation_cholesky=( None if correlation_cholesky is None else np.asarray(correlation_cholesky).copy() ), iteration=iteration, ) def _build_reused_vi_state(a, archive: _ReuseArchive, weights, origin_weights, ess: float): optimizer_samples, parameter_samples, qois, errors = _archive_arrays(archive) mean = np.asarray(a["variational_mean"]) log_std = np.asarray(a["variational_log_std"]) std, log_std = _vi._compute_variational_std( log_std, a["min_variational_std"], a["max_variational_std"] ) corr = a.get("variational_correlation_cholesky") observations = np.asarray(a["observations"]) log_likelihoods, misfits = _vi._compute_log_likelihoods( errors, a["observations_covariance"], a["covariance_regularization"], precision_operator=a.get("log_likelihood_precision_operator"), ) log_priors, log_jacobian, log_joint = _vi._compute_log_prior_and_joint_terms( log_likelihoods, parameter_samples, optimizer_samples, a["prior_mean"], a["prior_precision_operator"], a["prior_covariance_log_det"], a["bounded_parameter_handling"], a["parameter_mins"], a["parameter_maxes"], a["transform_interior_margin"], a["transform_map"], ) scale = float(a["elbo_scaling_factor"]) entropy_strategy = _vi._normalize_score_function_entropy_strategy( a["score_function_entropy_strategy"] ) gradient = _gradient_from_archive( optimizer_samples, scale * log_joint, mean, log_std, corr, weights, origin_weights, _vi._normalize_baseline_method(a["baseline_method"]), scale, entropy_strategy, ) gradient_mean, gradient_log_std = gradient[:2] update_mean, update_log_std, gradient_method = _vi._compute_update_directions( gradient_mean, gradient_log_std, std, a["gradient_method"] ) dimensionality = mean.size entropy = np.sum(log_std) + 0.5 * dimensionality * (1.0 + np.log(2.0 * np.pi)) if corr is not None: entropy += np.sum(np.log(np.diag(corr))) entropy *= scale weighted_joint = weights * log_joint normalized_weights = weights / np.sum(weights) zeros = np.zeros(mean.size) state = { "optimizer_samples": optimizer_samples, "parameter_samples": parameter_samples, "qois": qois, "mean_qoi": qois @ normalized_weights, "errors": errors, "log_likelihoods": weights * log_likelihoods, "raw_log_likelihoods": log_likelihoods, "log_priors": weights * log_priors, "raw_log_priors": log_priors, "log_joint_terms": weighted_joint, "raw_log_joint_terms": log_joint, "log_transform_jacobian": log_jacobian, "mean_misfit": float(np.mean(weights * misfits)), "mean_relative_mse": float(np.mean( weights * _vi._compute_relative_mse(errors, observations) )), "entropy": entropy, "elbo": scale * float(np.mean(weighted_joint)) + entropy, "gradient_mean": gradient_mean, "gradient_log_std": gradient_log_std, "hessian_diagonal_mean": zeros.copy(), "hessian_diagonal_log_std": zeros.copy(), "hessian_full": np.zeros((2 * mean.size, 2 * mean.size)), "update_direction_mean": update_mean, "update_direction_log_std": update_log_std, "gradient_method": gradient_method, "baseline_mean": gradient[2], "baseline_log_std": gradient[3], "gradient_signal_to_noise_ratio": gradient[4], "gradient_standard_error": gradient[5], "sample_reuse_used": True, "sample_reuse_ess": float(ess), "sample_reuse_archive_samples": archive.sample_count, "sample_reuse_archive_batches": len(archive.batches), "sample_reuse_refresh_reason": "reuse", "importance_weights": weights, "importance_origin_weights": origin_weights, } _, clipped_log_std = _vi._compute_variational_std( np.asarray(a["variational_log_std"]), a["min_variational_std"], a["max_variational_std"], ) hessian_full = _hessian_from_archive( state["optimizer_samples"], float(a["elbo_scaling_factor"]) * state["raw_log_joint_terms"], np.asarray(a["variational_mean"]), clipped_log_std, a.get("variational_correlation_cholesky"), weights, origin_weights, a["baseline_method"], ) dimensionality = np.asarray(a["variational_mean"]).size state["hessian_full"] = hessian_full state["hessian_diagonal_mean"] = np.diag( hessian_full[:dimensionality, :dimensionality] ) state["hessian_diagonal_log_std"] = np.diag( hessian_full[dimensionality:, dimensionality:] ) return state class _VIReuseController: def __init__(self, config: VISampleReuseConfig): self.archive = _ReuseArchive(config) self._periodic_refresh_iterations = set() def _periodic_due(self, iteration: int) -> bool: period = self.archive.config.periodic_refresh return ( period is not None and iteration > 0 and iteration % period == 0 and iteration not in self._periodic_refresh_iterations ) def _additional_reuse_quality(self, a, state, weights, origin_weights): """Run Newton safeguards inside the controller's shared refresh loop.""" if not _is_newton_reuse(self.archive): return True, "reuse", {} _, clipped_log_std = _vi._compute_variational_std( np.asarray(a["variational_log_std"]), a["min_variational_std"], a["max_variational_std"], ) return _hessian_reuse_quality( self.archive, np.asarray(state["optimizer_samples"]), float(a["elbo_scaling_factor"]) * np.asarray(state["raw_log_joint_terms"]), np.asarray(a["variational_mean"]), clipped_log_std, a.get("variational_correlation_cholesky"), np.asarray(weights), np.asarray(origin_weights), a["baseline_method"], np.asarray(state["hessian_full"]), int(a["sample_size"]), ) def _evaluate_current_archive(self, *args, **kwargs): bound = inspect.signature(_vi._evaluate_vi_state).bind(*args, **kwargs) bound.apply_defaults() a = bound.arguments iteration = _iteration_from_path(a["run_directory_base"]) limit = _iteration_archive_limit(self.archive.config, iteration) refresh_reasons = [] refresh_limit_reached = False final_diagnostics = {} while True: periodic_due = self._periodic_due(iteration) refresh, reasons, weight_pair, ess = _refresh_decision( self.archive, np.asarray(a["variational_mean"]), np.asarray(a["variational_log_std"]), a.get("variational_correlation_cholesky"), int(a["sample_size"]), periodic_due=periodic_due, ) candidate = None if not refresh: weights, origin_weights = weight_pair candidate = _build_reused_vi_state( a, self.archive, weights, origin_weights, ess ) quality_ok, reason, final_diagnostics = ( self._additional_reuse_quality( a, candidate, weights, origin_weights ) ) if not quality_ok: refresh = True reasons = (reason,) if not refresh: return _annotate_reuse_state( candidate, self.archive, ess, refresh_reasons, refresh_limit_reached, final_diagnostics, ) if len(refresh_reasons) >= limit: refresh_limit_reached = True if candidate is None: weights, origin_weights = _compute_importance_weights( self.archive, np.asarray(a["variational_mean"]), np.asarray(a["variational_log_std"]), a.get("variational_correlation_cholesky"), ) ess = _effective_sample_size(weights) candidate = _build_reused_vi_state( a, self.archive, weights, origin_weights, ess ) return _annotate_reuse_state( candidate, self.archive, ess, refresh_reasons, refresh_limit_reached, final_diagnostics, ) reason = "+".join(reasons) if periodic_due: self._periodic_refresh_iterations.add(iteration) fresh_kwargs = dict(a) if refresh_reasons: fresh_kwargs["run_directory_base"] = ( f'{a["run_directory_base"]}abris_refresh_' f'{len(refresh_reasons)}_' ) fresh_state = _vi._evaluate_vi_state(**fresh_kwargs) self.archive.append( _batch_from_vi_state( fresh_state, a["variational_mean"], a["variational_log_std"], a.get("variational_correlation_cholesky"), iteration, ), capacity=limit, ) refresh_reasons.append(reason) def evaluate_candidate(self, *args, **kwargs): bound = inspect.signature(_vi._evaluate_vi_candidate_for_line_search).bind(*args, **kwargs) bound.apply_defaults() a = bound.arguments if a["line_search_objective"] != "elbo": raise NotImplementedError( "Sample reuse currently requires line_search_objective='elbo'." ) state = self.evaluate_state( model=a["model"], observations=a["observations"], observations_covariance=a["observations_covariance"], run_directory_base=a["run_directory_base"], parameter_names=a["parameter_names"], variational_mean=a["variational_mean"], variational_log_std=a["variational_log_std"], prior_mean=a["prior_mean"], prior_precision_operator=a["prior_precision_operator"], prior_covariance_log_det=a["prior_covariance_log_det"], sample_size=a["sample_size"], evaluation_concurrency=a["evaluation_concurrency"], covariance_regularization=a["covariance_regularization"], baseline_method=a["baseline_method"], gradient_method=a["gradient_method"], bounded_parameter_handling=a["bounded_parameter_handling"], min_variational_std=a["min_variational_std"], max_variational_std=a["max_variational_std"], parameter_mins=a["parameter_mins"], parameter_maxes=a["parameter_maxes"], transform_interior_margin=a["transform_interior_margin"], transform_map=a["transform_map"], variational_correlation_cholesky=a["variational_correlation_cholesky"], elbo_scaling_factor=a["elbo_scaling_factor"], log_likelihood_precision_operator=a["log_likelihood_precision_operator"], sampling_method="mc", dispatcher=a["dispatcher"], score_function_entropy_strategy=a["score_function_entropy_strategy"], ) return { "optimizer_samples": state["optimizer_samples"], "parameter_samples": state["parameter_samples"], "iteration_results": { "qois": state["qois"], "mean-qoi": state["mean_qoi"], "errors": state["errors"], }, "mean_relative_mse": state["mean_relative_mse"], "state": state, } def evaluate_state(self, *args, **kwargs): bound = inspect.signature(_vi._evaluate_vi_state).bind(*args, **kwargs) bound.apply_defaults() run_directory_base = str(bound.arguments["run_directory_base"]) if "hessian_run_" not in run_directory_base: return self._evaluate_current_archive(*args, **kwargs) if not hasattr(self, "_independent_hessian_archive"): self._independent_hessian_archive = _ReuseArchive(self.archive.config) self._independent_hessian_archive.optimization_method = self.archive.optimization_method primary_archive = self.archive self.archive = self._independent_hessian_archive try: return self._evaluate_current_archive(*args, **kwargs) finally: self.archive = primary_archive def _validate_common_reuse_request(call_args, config): if _vi._normalize_sampling_method(call_args.get("sampling_method", "mc")) != "mc": raise NotImplementedError("Sample reuse currently supports sampling_method='mc' only.") baseline = call_args.get("baseline_method") baseline = "loo" if baseline is None else _vi._normalize_baseline_method(baseline) if baseline not in ("none", "loo"): raise NotImplementedError( "Sample reuse currently supports baseline_method='none' or 'loo'." ) optimization_method = _normalize_optimization_method( call_args.get("optimizer_method", "gradient") ) return optimization_method def _apply_alpha(base: np.ndarray, delta: np.ndarray, alpha, mode: str) -> np.ndarray: mode = _mf._normalize_mfmc_control_variate_mode(mode) if mode == "matrix": return base + delta @ alpha if mode == "scalar": return base + float(np.asarray(alpha)) * delta return base + np.asarray(alpha).reshape(-1) * delta def _mf_gradient_from_reuse(optimizer_samples_fom, optimizer_samples_rom_extra, mean, log_std, corr, fom_values, rom_base_values, rom_extra_values, importance_weights, origin_weights, baseline_method, scale, entropy_strategy, use_control_variate, control_variate_mode, mfmc_fixed_gain=1.0): score_mean_h, score_log_h = _score_functions( optimizer_samples_fom, mean, log_std, corr ) if optimizer_samples_rom_extra.shape[0] > 0: score_mean_e, score_log_e = _score_functions( optimizer_samples_rom_extra, mean, log_std, corr ) else: score_mean_e = score_log_e = None def prepare(values, samples): result = scale * np.asarray(values) if entropy_strategy == "joint": result = result - scale * _log_q(samples, mean, log_std, corr) return result high_values = prepare(fom_values, optimizer_samples_fom) low_base_values = prepare(rom_base_values, optimizer_samples_fom) low_extra_values = ( prepare(rom_extra_values, optimizer_samples_rom_extra) if score_mean_e is not None else np.zeros(0) ) if baseline_method == "loo": high_centered = high_values - _weighted_loo_baseline(high_values, origin_weights) low_base_centered = low_base_values - _weighted_loo_baseline( low_base_values, origin_weights ) low_extra_centered = ( low_extra_values - _vi._compute_leave_one_out_baseline(low_extra_values) if low_extra_values.size else low_extra_values ) else: high_centered, low_base_centered, low_extra_centered = ( high_values, low_base_values, low_extra_values ) def estimate(score_h, score_e): high_terms = importance_weights[:, None] * high_centered[:, None] * score_h low_base_terms = ( importance_weights[:, None] * low_base_centered[:, None] * score_h ) high_mean = np.mean(high_terms, axis=0) low_base_mean = np.mean(low_base_terms, axis=0) if score_e is None: return ( high_mean, _mf._constant_mfmc_gain(0.0, high_mean.shape, control_variate_mode), _vi._compute_component_standard_error(high_terms), ) low_extra_terms = low_extra_centered[:, None] * score_e low_extra_mean = np.mean(low_extra_terms, axis=0) if use_control_variate: alpha = _mf._compute_mfmc_alpha( high_terms, low_base_terms, mode=control_variate_mode ) else: mode = _mf._normalize_mfmc_control_variate_mode(control_variate_mode) alpha = _mf._constant_mfmc_gain(mfmc_fixed_gain, high_mean.shape, mode) ratio = score_e.shape[0] / float(score_h.shape[0] + score_e.shape[0]) estimate_value = _apply_alpha( high_mean, ratio * (low_extra_mean - low_base_mean), alpha, control_variate_mode, ) return estimate_value, alpha, _vi._compute_component_standard_error(high_terms) gradient_mean, alpha_mean, se_mean = estimate(score_mean_h, score_mean_e) gradient_log_std, alpha_log, se_log = estimate(score_log_h, score_log_e) if entropy_strategy == "analytic": gradient_log_std += scale standard_error = np.concatenate([se_mean, se_log]) snr = _vi._compute_gradient_signal_to_noise_ratio( np.concatenate([gradient_mean, gradient_log_std]), standard_error ) return gradient_mean, gradient_log_std, alpha_mean, alpha_log, snr, standard_error class _MFReuseController: def __init__(self, config: VISampleReuseConfig): self.archive = _ReuseArchive(config) self._periodic_refresh_iterations = set() def _periodic_due(self, iteration: int) -> bool: period = self.archive.config.periodic_refresh return ( period is not None and iteration > 0 and iteration % period == 0 and iteration not in self._periodic_refresh_iterations ) def _additional_reuse_quality(self, a, state, weights, origin_weights): """Run MF-Newton safeguards inside the shared refresh loop.""" if not _is_newton_reuse(self.archive): return True, "reuse", {} optimizer_fom = _archive_arrays(self.archive)[0] _, clipped_log_std = _vi._compute_variational_std( np.asarray(a["variational_log_std"]), a["min_variational_std"], a["max_variational_std"], ) # The variance trigger intentionally monitors the IS-reused HF curvature # contribution. Fresh ROM-only enrichment and the existing MF gain are left # unchanged; this isolates the quality of the recycled expensive samples. return _hessian_reuse_quality( self.archive, optimizer_fom, float(a["elbo_scaling_factor"]) * np.asarray(state["raw_log_joint_terms_fom"]), np.asarray(a["variational_mean"]), clipped_log_std, a.get("variational_correlation_cholesky"), np.asarray(weights), np.asarray(origin_weights), a["baseline_method"], np.asarray(state["hessian_full"]), int(a["fom_sample_size"]), ) def _append_from_state(self, state, mean, log_std, corr, iteration, capacity=None): n = state["parameter_samples_fom"].shape[0] self.archive.append(_ReuseBatch( optimizer_samples=np.asarray(state["optimizer_samples"])[:n].copy(), parameter_samples=np.asarray(state["parameter_samples_fom"]).copy(), qois=np.asarray(state["qois_fom"]).copy(), errors=np.asarray(state["errors_fom"]).copy(), variational_mean=np.asarray(mean).copy(), variational_log_std=np.asarray(log_std).copy(), variational_correlation_cholesky=( None if corr is None else np.asarray(corr).copy() ), iteration=iteration, ), capacity=capacity) def _evaluate_current_archive(self, *args, **kwargs): bound = inspect.signature(_mf._evaluate_mf_vi_state).bind(*args, **kwargs) bound.apply_defaults() a = dict(bound.arguments) iteration = _iteration_from_path(a["iteration_directory"]) limit = _iteration_archive_limit(self.archive.config, iteration) refresh_reasons = [] refresh_limit_reached = False final_diagnostics = {} while True: periodic_due = self._periodic_due(iteration) refresh, reasons, weight_pair, ess = _refresh_decision( self.archive, np.asarray(a["variational_mean"]), np.asarray(a["variational_log_std"]), a.get("variational_correlation_cholesky"), int(a["fom_sample_size"]), periodic_due=periodic_due, ) candidate = None if not refresh and a.get("rom_model") is not None: weights, origin_weights = weight_pair candidate = self._build_reused_state( a, weights, origin_weights, ess ) quality_ok, reason, final_diagnostics = ( self._additional_reuse_quality( a, candidate, weights, origin_weights ) ) if not quality_ok: refresh = True reasons = (reason,) elif a.get("rom_model") is None and not refresh: refresh = True reasons = ("missing_rom",) if not refresh: return _annotate_reuse_state( candidate, self.archive, ess, refresh_reasons, refresh_limit_reached, final_diagnostics, ) if len(refresh_reasons) >= limit: refresh_limit_reached = True weights, origin_weights = _compute_importance_weights( self.archive, np.asarray(a["variational_mean"]), np.asarray(a["variational_log_std"]), a.get("variational_correlation_cholesky"), ) ess = _effective_sample_size(weights) candidate = self._build_reused_state( a, weights, origin_weights, ess ) return _annotate_reuse_state( candidate, self.archive, ess, refresh_reasons, refresh_limit_reached, final_diagnostics, ) reason = "+".join(reasons) if periodic_due: self._periodic_refresh_iterations.add(iteration) fresh_args = dict(a) if refresh_reasons: fresh_args["iteration_directory"] = ( f'{a["iteration_directory"]}/abris_refresh_' f'{len(refresh_reasons)}' ) fresh_state = _mf._evaluate_mf_vi_state(**fresh_args) self._append_from_state( fresh_state, a["variational_mean"], a["variational_log_std"], a.get("variational_correlation_cholesky"), iteration, capacity=limit, ) refresh_reasons.append(reason) for key in ( "rom_model", "training_dirs", "training_parameters", "training_qois", "rom_training_dirs", "rom_training_parameters", "rom_training_qois", ): a[key] = fresh_state[key] def _build_reused_state(self, a, weights, origin_weights, ess): dispatcher = resolve_dispatcher(a["dispatcher"]) rom_dispatcher = resolve_local_dispatcher(dispatcher) optimizer_fom, parameter_fom, qois_fom, errors_fom = _archive_arrays(self.archive) mean = np.asarray(a["variational_mean"]) log_std = np.asarray(a["variational_log_std"]) corr = a.get("variational_correlation_cholesky") rom_model = a["rom_model"] parameter_names = a["parameter_names"] iteration_directory = a["iteration_directory"] bootstrap = _iteration_from_path(iteration_directory) == 0 rom_base = _vi.run_vi_iteration( rom_model, a["observations"], f"{iteration_directory}/run_rom_reuse_base_", parameter_names, parameter_fom, a["rom_evaluation_concurrency"], rom_dispatcher, ) n_extra = int(a["rom_extra_sample_size"]) if n_extra > 0: optimizer_extra, parameter_extra = _vi._draw_parameter_samples( mean, log_std, n_extra, a["min_variational_std"], a["max_variational_std"], a["bounded_parameter_handling"], a["parameter_mins"], a["parameter_maxes"], transform_interior_margin=a["transform_interior_margin"], transform_map=a["transform_map"], variational_correlation_cholesky=corr, sampling_method="mc", ) rom_extra = _vi.run_vi_iteration( rom_model, a["observations"], f"{iteration_directory}/run_rom_reuse_extra_", parameter_names, parameter_extra, a["rom_evaluation_concurrency"], rom_dispatcher, ) else: optimizer_extra = np.zeros((0, mean.size)) parameter_extra = np.zeros((0, mean.size)) rom_extra = { "qois": np.zeros((qois_fom.shape[0], 0)), "mean-qoi": np.zeros(qois_fom.shape[0]), "errors": np.zeros((errors_fom.shape[0], 0)), } precision = a.get("log_likelihood_precision_operator") fom_ll, fom_misfits = _vi._compute_log_likelihoods( errors_fom, a["observations_covariance"], a["covariance_regularization"], precision_operator=precision, ) base_ll, _ = _vi._compute_log_likelihoods( rom_base["errors"], a["observations_covariance"], a["covariance_regularization"], precision_operator=precision, ) extra_ll = ( _vi._compute_log_likelihoods( rom_extra["errors"], a["observations_covariance"], a["covariance_regularization"], precision_operator=precision, )[0] if n_extra > 0 else np.zeros(0) ) common_joint_args = ( a["prior_mean"], a["prior_precision_operator"], a["prior_covariance_log_det"], a["bounded_parameter_handling"], a["parameter_mins"], a["parameter_maxes"], a["transform_interior_margin"], a["transform_map"], ) fom_lp, fom_jac, fom_joint = _vi._compute_log_prior_and_joint_terms( fom_ll, parameter_fom, optimizer_fom, *common_joint_args ) base_lp, base_jac, base_joint = _vi._compute_log_prior_and_joint_terms( base_ll, parameter_fom, optimizer_fom, *common_joint_args ) if n_extra > 0: extra_lp, extra_jac, extra_joint = _vi._compute_log_prior_and_joint_terms( extra_ll, parameter_extra, optimizer_extra, *common_joint_args ) else: extra_lp = extra_jac = extra_joint = np.zeros(0) baseline = _vi._normalize_baseline_method(a["baseline_method"]) entropy_strategy = _vi._normalize_score_function_entropy_strategy( a["score_function_entropy_strategy"] ) scale = float(a["elbo_scaling_factor"]) gradient = _mf_gradient_from_reuse( optimizer_fom, optimizer_extra, mean, log_std, corr, fom_joint, base_joint, extra_joint, weights, origin_weights, baseline, scale, entropy_strategy, a["use_mfmc_control_variate"] and not bootstrap, a["mfmc_control_variate_mode"], mfmc_fixed_gain=(1.0 if bootstrap and a["use_mfmc_control_variate"] else a["mfmc_fixed_gain"]), ) gradient_mean, gradient_log_std, alpha_mean, alpha_log = gradient[:4] std, clipped_log_std = _vi._compute_variational_std( log_std, a["min_variational_std"], a["max_variational_std"] ) update_mean, update_log, gradient_method = _vi._compute_update_directions( gradient_mean, gradient_log_std, std, a["gradient_method"] ) dimensionality = mean.size entropy = np.sum(clipped_log_std) + 0.5 * dimensionality * (1.0 + np.log(2.0 * np.pi)) if corr is not None: entropy += np.sum(np.log(np.diag(corr))) entropy *= scale hf_mean = float(np.mean(weights * fom_joint)) if n_extra > 0: ratio = n_extra / float(optimizer_fom.shape[0] + n_extra) joint_mean = hf_mean + ratio * ( float(np.mean(extra_joint)) - float(np.mean(weights * base_joint)) ) else: joint_mean = hf_mean normalized_weights = weights / np.sum(weights) zeros = np.zeros(mean.size) weighted_fom_joint = weights * fom_joint weighted_base_joint = weights * base_joint optimizer_all = np.vstack([optimizer_fom, optimizer_fom, optimizer_extra]) parameter_all = np.vstack([parameter_fom, parameter_fom, parameter_extra]) state = { "rom_retraining_strategy": a["rom_retraining_strategy"], "gradient_gain_estimation_strategy": a["gradient_gain_estimation_strategy"], "mfmc_fixed_gain": a["mfmc_fixed_gain"], "hessian_gain_estimation_strategy": a["hessian_gain_estimation_strategy"], "bootstrap_rom": bootstrap, "rom_adaptation_required": False, "pending_rom_model": None, "pending_rom_training_dirs": [], "pending_rom_training_parameters": None, "pending_rom_training_qois": None, "gradient_gain_samples": { "mean": np.broadcast_to(alpha_mean, (optimizer_fom.shape[0],) + np.shape(alpha_mean)), "log_std": np.broadcast_to(alpha_log, (optimizer_fom.shape[0],) + np.shape(alpha_log)), }, "hessian_gain_samples": {}, "optimizer_samples": optimizer_all, "parameter_samples": parameter_all, "parameter_samples_fom": parameter_fom, "parameter_samples_rom_base": parameter_fom.copy(), "parameter_samples_rom_only": parameter_extra, "qois_fom": qois_fom, "mean_qoi_fom": qois_fom @ normalized_weights, "errors_fom": errors_fom, "qois_rom_base": rom_base["qois"], "qois_rom_coupled": rom_base["qois"], "qois_rom_only": rom_extra["qois"], "log_likelihoods_fom": weights * fom_ll, "raw_log_likelihoods_fom": fom_ll, "log_priors_fom": weights * fom_lp, "raw_log_priors_fom": fom_lp, "log_joint_terms_fom": weighted_fom_joint, "raw_log_joint_terms_fom": fom_joint, "log_transform_jacobian_fom": fom_jac, "log_likelihoods_rom_base": weights * base_ll, "log_priors_rom_base": weights * base_lp, "log_joint_terms_rom_base": weighted_base_joint, "log_transform_jacobian_rom_base": base_jac, "log_likelihoods_rom_coupled": weights * base_ll, "log_likelihoods_rom_only": extra_ll, "log_priors_rom_only": extra_lp, "log_joint_terms_rom_only": extra_joint, "log_transform_jacobian_rom_only": extra_jac, "mean_misfit": float(np.mean(weights * fom_misfits)), "mean_relative_mse": float(np.mean( weights * _vi._compute_relative_mse(errors_fom, a["observations"]) )), "entropy": entropy, "elbo": scale * joint_mean + entropy, "gradient_mean": gradient_mean, "gradient_log_std": gradient_log_std, "hessian_diagonal_mean": zeros.copy(), "hessian_diagonal_log_std": zeros.copy(), "hessian_full": np.zeros((2 * mean.size, 2 * mean.size)), "update_direction_mean": update_mean, "update_direction_log_std": update_log, "gradient_method": gradient_method, "baseline_mean": zeros.copy(), "baseline_log_std": zeros.copy(), "gradient_signal_to_noise_ratio": gradient[4], "gradient_standard_error": gradient[5], "mfmc_alpha_mean": alpha_mean, "mfmc_alpha_log_std": alpha_log, "rom_error": _mf._compute_rom_relative_error(rom_base["qois"], qois_fom), "rom_rebuilt_this_iteration": False, "rom_model": rom_model, "training_dirs": a["training_dirs"], "training_parameters": a["training_parameters"], "training_qois": a["training_qois"], "rom_training_dirs": a["rom_training_dirs"], "rom_training_parameters": a["rom_training_parameters"], "rom_training_qois": a["rom_training_qois"], "sample_reuse_used": True, "sample_reuse_ess": float(ess), "sample_reuse_archive_samples": self.archive.sample_count, "sample_reuse_archive_batches": len(self.archive.batches), "sample_reuse_refresh_reason": "reuse", "importance_weights": weights, "importance_origin_weights": origin_weights, } optimizer_fom = _archive_arrays(self.archive)[0] n_fom = optimizer_fom.shape[0] optimizer_extra = np.asarray(state["optimizer_samples"])[2 * n_fom :] rom_base_errors = ( np.asarray(state["qois_rom_base"]) - np.asarray(a["observations"])[:, None] ) rom_base_log_likelihoods, _ = _vi._compute_log_likelihoods( rom_base_errors, a["observations_covariance"], a["covariance_regularization"], precision_operator=a.get("log_likelihood_precision_operator"), ) _, _, raw_rom_base_joint = _vi._compute_log_prior_and_joint_terms( rom_base_log_likelihoods, np.asarray(state["parameter_samples_rom_base"]), optimizer_fom, a["prior_mean"], a["prior_precision_operator"], a["prior_covariance_log_det"], a["bounded_parameter_handling"], a["parameter_mins"], a["parameter_maxes"], a["transform_interior_margin"], a["transform_map"], ) hessian_full = _mf_hessian_from_reuse( optimizer_fom, optimizer_extra, np.asarray(a["variational_mean"]), _vi._compute_variational_std( np.asarray(a["variational_log_std"]), a["min_variational_std"], a["max_variational_std"], )[1], a.get("variational_correlation_cholesky"), np.asarray(state["raw_log_joint_terms_fom"]), raw_rom_base_joint, np.asarray(state["log_joint_terms_rom_only"]), weights, origin_weights, a["baseline_method"], a["elbo_scaling_factor"], a["use_mfmc_control_variate"], a["mfmc_control_variate_mode"], mfmc_fixed_gain=a["mfmc_fixed_gain"], ) dimensionality = np.asarray(a["variational_mean"]).size state["hessian_full"] = hessian_full state["hessian_diagonal_mean"] = np.diag( hessian_full[:dimensionality, :dimensionality] ) state["hessian_diagonal_log_std"] = np.diag( hessian_full[dimensionality:, dimensionality:] ) return state def evaluate_state(self, *args, **kwargs): bound = inspect.signature(_mf._evaluate_mf_vi_state).bind(*args, **kwargs) bound.apply_defaults() iteration_directory = str(bound.arguments["iteration_directory"]).rstrip("/") if not iteration_directory.endswith("/hessian"): return self._evaluate_current_archive(*args, **kwargs) if not hasattr(self, "_independent_hessian_archive"): self._independent_hessian_archive = _ReuseArchive(self.archive.config) self._independent_hessian_archive.optimization_method = self.archive.optimization_method primary_archive = self.archive self.archive = self._independent_hessian_archive try: return self._evaluate_current_archive(*args, **kwargs) finally: self.archive = primary_archive def _compute_hessian_score_blocks(samples: np.ndarray, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky): """Return score-Hessian factors for mean, log-std, and cross blocks.""" std = np.exp(np.asarray(log_std, dtype=float)) centered = samples - mean[None, :] normalized = centered / std[None, :] dimensionality = mean.size if correlation_cholesky is None: score_mean = centered / (std[None, :] ** 2) score_log_std = normalized ** 2 - 1.0 score_mean_outer = score_mean[:, :, None] * score_mean[:, None, :] score_log_std_outer = score_log_std[:, :, None] * score_log_std[:, None, :] score_cross_outer = score_mean[:, :, None] * score_log_std[:, None, :] second_mean = np.zeros_like(score_mean_outer) second_log_std = np.zeros_like(score_log_std_outer) second_cross = np.zeros_like(score_cross_outer) index = np.arange(dimensionality) second_mean[:, index, index] = -1.0 / (std ** 2) second_log_std[:, index, index] = -2.0 * (normalized ** 2) second_cross[:, index, index] = -2.0 * score_mean else: identity = np.eye(dimensionality) correlation_solve = np.linalg.solve(correlation_cholesky, identity) correlation_inverse = np.linalg.solve( correlation_cholesky.transpose(), correlation_solve ) correlation_solve_samples = np.linalg.solve( correlation_cholesky, normalized.transpose() ) inverse_times_normalized = np.linalg.solve( correlation_cholesky.transpose(), correlation_solve_samples ).transpose() score_mean = inverse_times_normalized / std[None, :] score_log_std = normalized * inverse_times_normalized - 1.0 score_mean_outer = score_mean[:, :, None] * score_mean[:, None, :] score_log_std_outer = score_log_std[:, :, None] * score_log_std[:, None, :] score_cross_outer = score_mean[:, :, None] * score_log_std[:, None, :] sample_count = samples.shape[0] inverse_std_outer = 1.0 / (std[:, None] * std[None, :]) second_mean = np.broadcast_to( -correlation_inverse * inverse_std_outer, (sample_count, dimensionality, dimensionality), ).copy() outer_normalized = normalized[:, :, None] * normalized[:, None, :] second_log_std = -(outer_normalized * correlation_inverse[None, :, :]) index = np.arange(dimensionality) second_log_std[:, index, index] -= normalized * inverse_times_normalized second_cross = -( (normalized[:, None, :] * correlation_inverse[None, :, :]) / std[None, :, None] ) second_cross[:, index, index] -= score_mean return ( score_mean_outer + second_mean, score_log_std_outer + second_log_std, score_cross_outer + second_cross, ) def _assemble_hessian_score_matrices(score_blocks) -> np.ndarray: mean_scores, log_std_scores, cross_scores = score_blocks top = np.concatenate([mean_scores, cross_scores], axis=2) bottom = np.concatenate( [np.swapaxes(cross_scores, 1, 2), log_std_scores], axis=2 ) return np.concatenate([top, bottom], axis=1) def _center_reused_hessian_values(values: np.ndarray, origin_weights: np.ndarray, baseline_method: str) -> np.ndarray: baseline_method = _vi._normalize_baseline_method(baseline_method) if baseline_method == "loo": return values - _weighted_loo_baseline(values, origin_weights) if baseline_method == "none": return values raise NotImplementedError( "Sample reuse currently supports baseline_method='none' or 'loo'." ) def _hessian_sample_terms(samples: np.ndarray, values: np.ndarray, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky, importance_weights: np.ndarray, origin_weights: np.ndarray, baseline_method: str) -> np.ndarray: score_matrices = _assemble_hessian_score_matrices( _compute_hessian_score_blocks( samples, mean, log_std, correlation_cholesky ) ) centered = _center_reused_hessian_values( np.asarray(values, dtype=float), origin_weights, baseline_method ) return ( np.asarray(importance_weights)[:, None, None] * centered[:, None, None] * score_matrices ) def _hessian_from_archive(samples: np.ndarray, values: np.ndarray, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky, importance_weights: np.ndarray, origin_weights: np.ndarray, baseline_method: str) -> np.ndarray: """Estimate the score-function Hessian from a heterogeneous MIS archive.""" terms = _hessian_sample_terms( samples, values, mean, log_std, correlation_cholesky, importance_weights, origin_weights, baseline_method, ) hessian_full = np.mean(terms, axis=0) hessian_full = 0.5 * (hessian_full + hessian_full.transpose()) return np.nan_to_num(hessian_full, nan=0.0, posinf=0.0, neginf=0.0) def _second_order_score_diagnostics(archive, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky, importance_weights: np.ndarray, reference_sample_count: int): """Compare recycled and fresh estimates of the zero second-order score moment.""" samples = _archive_arrays(archive)[0] recycled_scores = _assemble_hessian_score_matrices( _compute_hessian_score_blocks( samples, mean, log_std, correlation_cholesky ) ) recycled_error_matrix = np.mean( importance_weights[:, None, None] * recycled_scores, axis=0 ) reference_samples = _draw_optimizer_only( mean, log_std, reference_sample_count, correlation_cholesky, ) reference_scores = _assemble_hessian_score_matrices( _compute_hessian_score_blocks( reference_samples, mean, log_std, correlation_cholesky ) ) reference_error_matrix = np.mean(reference_scores, axis=0) return ( float(np.linalg.norm(recycled_error_matrix, ord="fro")), float(np.linalg.norm(reference_error_matrix, ord="fro")), ) def _batch_aware_hessian_standard_error(sample_terms: np.ndarray, archive) -> float: """Return the Frobenius aggregate SE for a deterministic-mixture archive. Each retained batch is treated as an independent stratum. For batch ``b`` with fraction ``beta_b`` and sample covariance ``S_b``, the covariance of the deterministic-mixture mean contributes ``beta_b**2 S_b / N_b``. Only the trace of that covariance is required for the Frobenius aggregate. """ sample_terms = np.asarray(sample_terms, dtype=float) total_count = int(sample_terms.shape[0]) if total_count <= 1: return np.inf variance_sum = 0.0 offset = 0 used_batch_variance = False for batch in archive.batches: batch_count = int(batch.size) sl = slice(offset, offset + batch_count) flat_terms = sample_terms[sl].reshape(batch_count, -1) if batch_count > 1: beta = batch_count / float(total_count) component_variances = np.var(flat_terms, axis=0, ddof=1) variance_sum += ( beta ** 2 * float(np.sum(component_variances)) / batch_count ) used_batch_variance = True offset += batch_count if not used_batch_variance: flat_terms = sample_terms.reshape(total_count, -1) variance_sum = float(np.sum(np.var(flat_terms, axis=0, ddof=1))) / total_count return float(np.sqrt(max(variance_sum, 0.0))) def _hessian_reuse_quality(archive, samples: np.ndarray, values: np.ndarray, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky, importance_weights: np.ndarray, origin_weights: np.ndarray, baseline_method: str, _hessian_full: np.ndarray, reference_sample_count: int): """Evaluate Newton-specific reuse diagnostics without new model calls.""" config = archive.config diagnostics = { "sample_reuse_hessian_score_error": np.nan, "sample_reuse_hessian_score_reference_error": np.nan, "sample_reuse_hessian_standard_error": np.nan, "sample_reuse_hessian_relative_standard_error": np.nan, } if getattr(config, "use_hessian_score_diagnostic", False): recycled_error, reference_error = _second_order_score_diagnostics( archive, mean, log_std, correlation_cholesky, importance_weights, reference_sample_count, ) diagnostics["sample_reuse_hessian_score_error"] = recycled_error diagnostics["sample_reuse_hessian_score_reference_error"] = reference_error reference_scale = max(reference_error, np.sqrt(np.finfo(float).eps)) error_scale = float(getattr(config, "hessian_score_error_scale", 2.0)) if recycled_error > error_scale * reference_scale: return False, "hessian_score", diagnostics threshold = getattr( config, "hessian_relative_standard_error_threshold", None ) if threshold is not None: terms = _hessian_sample_terms( samples, values, mean, log_std, correlation_cholesky, importance_weights, origin_weights, baseline_method, ) standard_error = _batch_aware_hessian_standard_error(terms, archive) # Normalize by the same recycled HF curvature contribution whose # uncertainty is measured above. In MFVI, using the full multifidelity # Hessian here can spuriously inflate the relative error when the ROM # control-variate correction cancels part of the HF curvature. recycled_hessian = np.mean(terms, axis=0) recycled_hessian = 0.5 * ( recycled_hessian + recycled_hessian.transpose() ) hessian_norm = float(np.linalg.norm(recycled_hessian, ord="fro")) denominator = max(hessian_norm, np.sqrt(np.finfo(float).eps)) relative_standard_error = standard_error / denominator diagnostics["sample_reuse_hessian_standard_error"] = standard_error diagnostics[ "sample_reuse_hessian_relative_standard_error" ] = relative_standard_error if not np.isfinite(relative_standard_error) or relative_standard_error > threshold: return False, "hessian_variance", diagnostics return True, "reuse", diagnostics def _mf_hessian_from_reuse(optimizer_samples_fom: np.ndarray, optimizer_samples_rom_extra: np.ndarray, mean: np.ndarray, log_std: np.ndarray, correlation_cholesky, fom_values: np.ndarray, rom_base_values: np.ndarray, rom_extra_values: np.ndarray, importance_weights: np.ndarray, origin_weights: np.ndarray, baseline_method: str, elbo_scaling_factor: float, use_control_variate: bool, control_variate_mode: str, mfmc_fixed_gain: float = 1.0) -> np.ndarray: """MFVI Hessian with MIS-reused coupled HF/LF samples and fresh LF extras.""" high_scores = _compute_hessian_score_blocks( optimizer_samples_fom, mean, log_std, correlation_cholesky ) low_base_scores = high_scores if optimizer_samples_rom_extra.shape[0] > 0: low_extra_scores = _compute_hessian_score_blocks( optimizer_samples_rom_extra, mean, log_std, correlation_cholesky ) else: low_extra_scores = (None, None, None) scale = float(elbo_scaling_factor) high_values = scale * np.asarray(fom_values, dtype=float) low_base_values = scale * np.asarray(rom_base_values, dtype=float) low_extra_values = scale * np.asarray(rom_extra_values, dtype=float) baseline_method = _vi._normalize_baseline_method(baseline_method) if baseline_method == "loo": high_centered = high_values - _weighted_loo_baseline( high_values, origin_weights ) low_base_centered = low_base_values - _weighted_loo_baseline( low_base_values, origin_weights ) low_extra_centered = ( low_extra_values - _vi._compute_leave_one_out_baseline(low_extra_values) if low_extra_values.size else low_extra_values ) elif baseline_method == "none": high_centered = high_values low_base_centered = low_base_values low_extra_centered = low_extra_values else: raise NotImplementedError( "Sample reuse currently supports baseline_method='none' or 'loo'." ) def estimate_block(high_score, low_base_score, low_extra_score): high_terms = ( importance_weights[:, None, None] * high_centered[:, None, None] * high_score ) low_base_terms = ( importance_weights[:, None, None] * low_base_centered[:, None, None] * low_base_score ) low_extra_terms = None if low_extra_score is not None: low_extra_terms = low_extra_centered[:, None, None] * low_extra_score estimate, _ = _mf._mfmc_gradient_estimator( high_terms, low_base_terms, low_extra_terms, use_control_variate, control_variate_mode, mfmc_fixed_gain=mfmc_fixed_gain, ) return estimate hessian_mean = estimate_block(high_scores[0], low_base_scores[0], low_extra_scores[0]) hessian_log_std = estimate_block( high_scores[1], low_base_scores[1], low_extra_scores[1] ) hessian_cross = estimate_block( high_scores[2], low_base_scores[2], low_extra_scores[2] ) hessian_full = np.block([ [hessian_mean, hessian_cross], [hessian_cross.transpose(), hessian_log_std], ]) hessian_full = 0.5 * (hessian_full + hessian_full.transpose()) return np.nan_to_num(hessian_full, nan=0.0, posinf=0.0, neginf=0.0) def _is_newton_reuse(archive) -> bool: return archive.optimization_method == "newton"
[docs] def make_controller(config, call_args, *, multifidelity=False): """Create a private evaluator for this run, leaving module globals untouched.""" if config is None or not config.enabled: return None if not isinstance(config, VISampleReuseConfig): raise TypeError("sample_reuse_config must be VISampleReuseConfig or None") method = _validate_common_reuse_request(call_args, config) if multifidelity and (call_args["rom_retraining_strategy"] != "same_sample" or call_args["gradient_gain_estimation_strategy"] != "same_sample"): raise NotImplementedError( "MFVI sample reuse requires rom_retraining_strategy='same_sample' " "and gradient_gain_estimation_strategy='same_sample'." ) controller = (_MFReuseController if multifidelity else _VIReuseController)(config) controller.archive.optimization_method = method return controller